{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "view-in-github"
   },
   "source": [
    "<a href=\"https://colab.research.google.com/github/nsanghi/drl-2ed/blob/main/chapter6/6.a-dqn-pytorch.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Qeb-JHsFlNvF"
   },
   "source": [
    "# Deep Q-Network implementation (PyTorch).\n",
    "\n",
    "In this notebook, we will implement DQN with **experience replay** and **target networks**.\n",
    "\n",
    "Q Learning control is carried out by sampling step by step and updating Q values at each step. We use $\\epsilon$-greedy policy to explore and generate samples. However, the policy learnt is a deterministic greedy policy with no exploration. We can carryout updates online i.e. we take a step and use `(current state, action, reward and next_state)` tuple to update.\n",
    "\n",
    "In case of function approximation using neural network, the input to the network is the state and output is the $q(s,a)$ for all the actions in the state $s$. It is denoted as $ \\hat{q}(s_t, a_t; w_{t}) $, where $w_{t}$ is the weigths of the neural network that we learn as part of DQN learning.\n",
    "\n",
    "We use two networks, one target network with weight $w^-_t$ to get the max $q$-value of next state with best action denoted by $ \\max\\limits_a \\hat {q}(S_{t+1},a; w^{-}_{t}) $ and network with weights $w_t^-$ which we periodically updated from primary network $w_t$.\n",
    "\n",
    "The Update equation is given below. This is the online version:\n",
    "$$ w_{t+1} \\leftarrow w_t + \\alpha [ R_{t+1} + \\gamma . \\max_{a} \\hat{q}(S_{t+1},a;w^{-}_{t}) – \\hat{q}(S_t,A_t;w_t)] \\nabla \\hat{q}_{w_t}(S_t,A_t;w_t)$$\n",
    "\n",
    "Online update with neural network with millions of weights does not work well. Accordingly, We use experience replay (aka Replay Buffer).  We use a behavior policy to explore the environment and store the samples `(s, a, r, s', done)` in a buffer. The samples are generated using an exploratory behavior policy while we improve a deterministic target policy using q-values.\n",
    "\n",
    "Therefore, we can always use older samples from behavior policy and apply them again and again. We can keep the buffer size fixed to some pre-determined size and keep deleting the older samples as we collect new ones. This process makes learning sample efficient by reusing a sample multiple times and also removing temporal dependence of the samples we would otherwise see while following a trajectory.\n",
    "\n",
    "The update equation with batch update with minor modifications is given below. We collect samples of transitions `(current state, action, reward, next state)` in a buffer, where each sample is denoted as a tuple:\n",
    "\n",
    "$$ (s_{i}, a_{i}, r_{i}, s'_{i}, done_{i})$$\n",
    "\n",
    "Subscript ($i$) denotes ith sample. We take $N$ samples from experience replay selecting randomly and update the weights. Subscript ($t$) denotes the index of weight updates. If the current state is done, as denoted by `done` flag, the target is just the reward as terminal states have zero value. The final update equation is as given below:\n",
    "\n",
    "$$w_{t+1} \\leftarrow w_t + \\alpha \\frac{1}{N} \\sum_{i=1}^{N} \\left[ r_i + \\left( (1-done_i) . \\gamma .  \\max_{a'} \\hat{q}(s'_{i},a';w^{-}_{t}) \\right) – \\hat{q}(s_i,a_i;w_t) \\right] \\nabla \\hat{q}(s_i,a_i;w_t)$$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "aj1mKsDflNvJ"
   },
   "source": [
    "#### Running in Colab/Kaggle\n",
    "\n",
    "If you are running this on Colab, please uncomment below cells and run this to install required dependencies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## uncomment and execute this cell to install all the the dependencies if running in Google Colab or Kaggle\n",
    "# !apt-get update \n",
    "# !apt-get install -y swig cmake ffmpeg freeglut3-dev xvfb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "KmUPJdmplNvJ",
    "outputId": "651a7b66-af14-4734-cbe6-3fb48024d019"
   },
   "outputs": [],
   "source": [
    "## Uncomment and execute this cell to install all the the dependencies if running in Google Colab or Kaggle\n",
    "\n",
    "## Uncomment and run for Colab\n",
    "# !git clone https://github.com/nsanghi/drl-2ed\n",
    "# %cd /content/drl-2ed \n",
    "# !pip install  -r requirements.txt\n",
    "# %cd chapter6\n",
    "\n",
    "\n",
    "## Uncomment and run for Kaggle\n",
    "# !git clone https://github.com/nsanghi/drl-2ed\n",
    "# %cd /kaggle/working/drl-2ed \n",
    "# !pip install  -r requirements.txt\n",
    "# %cd chapter6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Uncomment and Rerun the cd command in case you were asked to restart the kernel and you followed that message\n",
    "## as after resart the kernel will again point back to root folder\n",
    "\n",
    "\n",
    "## Uncomment and run for Colab\n",
    "# %cd /content/drl-2ed \n",
    "# %cd chapter6\n",
    "\n",
    "\n",
    "## Uncomment and run for Kaggle\n",
    "# %cd /kaggle/working/drl-2ed \n",
    "# %cd chapter6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "x5HqyCtYlNvL"
   },
   "source": [
    "### Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "uimUuLkxlNvL"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-11-05 05:52:50.931275: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
      "2023-11-05 05:52:51.215058: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
      "2023-11-05 05:52:51.215102: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
      "2023-11-05 05:52:51.217335: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
      "2023-11-05 05:52:51.335399: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 AVX_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2023-11-05 05:52:52.688145: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import gymnasium as gym\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.signal import convolve, gaussian\n",
    "from stable_baselines3.common.vec_env import VecVideoRecorder, DummyVecEnv\n",
    "from base64 import b64encode\n",
    "\n",
    "from IPython.display import HTML\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "udtxVxvKlNvM"
   },
   "source": [
    "### Environment - CartPole\n",
    "\n",
    "We can use the setup here to run on any environment which has state as a single vector and actions are discrete. We will build it on Cart Pole. In another notebook we will run this other environments like Atari games and a few more.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "Lfnu0yo5lNvM"
   },
   "outputs": [],
   "source": [
    "def make_env(env_name):\n",
    "    # increase time limit from 200/500 to 4000\n",
    "    env = gym.make(env_name, render_mode=\"rgb_array\", max_episode_steps=4000)\n",
    "    return env"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 431
    },
    "id": "QcihCz8tlNvM",
    "outputId": "5241df64-adbc-4f34-9df0-a8f6357b453c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "state shape:(4,)\n",
      "Number of Actions:2\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "env_name = 'CartPole-v1'\n",
    "seed=123\n",
    "\n",
    "env = make_env(env_name)\n",
    "env.reset(seed=seed)\n",
    "plt.imshow(env.render())\n",
    "state_shape, n_actions = env.observation_space.shape, env.action_space.n\n",
    "print(f\"state shape:{state_shape}\\nNumber of Actions:{n_actions}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Pzl8gQpelNvN"
   },
   "source": [
    "### Building a network using pytorch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bnByD2kDlNvN"
   },
   "source": [
    "Let us build a DQN agent using a simple network. We now need to build a neural network that can map states/observations to state q-values. The observation space and action space is as given below for CartPole\n",
    "\n",
    "    Observation:\n",
    "        Type: Box(4)\n",
    "        Num     Observation               Min                     Max\n",
    "        0       Cart Position             -4.8                    4.8\n",
    "        1       Cart Velocity             -Inf                    Inf\n",
    "        2       Pole Angle                -0.418 rad (-24 deg)    0.418 rad (24 deg)\n",
    "        3       Pole Angular Velocity     -Inf                    Inf\n",
    "    Actions:\n",
    "        Type: Discrete(2)\n",
    "        Num   Action\n",
    "        0     Push cart to the left\n",
    "        1     Push cart to the right\n",
    "        \n",
    "\n",
    "The model will be a simple one with 2 hidden layers with Relu activation and final layer being logits with dimension equal to number of actions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "QggxNgeTlNvN",
    "outputId": "903fac64-896d-4c6b-beff-fcb3b38d682f"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cpu')"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "id": "BWDHLS6QlNvO"
   },
   "outputs": [],
   "source": [
    "class DQNAgent(nn.Module):\n",
    "    def __init__(self, state_shape, n_actions, epsilon=0):\n",
    "\n",
    "        super().__init__()\n",
    "        self.epsilon = epsilon\n",
    "        self.n_actions = n_actions\n",
    "        self.state_shape = state_shape\n",
    "\n",
    "        state_dim = state_shape[0]\n",
    "        # a simple NN with state_dim as input vector (input is state s)\n",
    "        # and self.n_actions as output vector of logits of q(s, a)\n",
    "        self.network = nn.Sequential()\n",
    "        self.network.add_module('layer1', nn.Linear(state_dim, 256))\n",
    "        self.network.add_module('relu1', nn.ReLU())\n",
    "        self.network.add_module('layer2', nn.Linear(256, 256))\n",
    "        self.network.add_module('relu2', nn.ReLU())\n",
    "        self.network.add_module('layer3', nn.Linear(256, n_actions))\n",
    "        #\n",
    "        self.parameters = self.network.parameters\n",
    "\n",
    "    def forward(self, state_t):\n",
    "        # pass the state at time t through the network to get Q(s,a)\n",
    "        qvalues = self.network(state_t)\n",
    "        return qvalues\n",
    "\n",
    "    def get_qvalues(self, states):\n",
    "        # input is an array of states in numpy and output is Qvals as numpy array\n",
    "        states = torch.tensor(np.array(states), device=device, dtype=torch.float32)\n",
    "        qvalues = self.forward(states)\n",
    "        return qvalues.data.cpu().numpy()\n",
    "\n",
    "    def get_action(self, states):\n",
    "        states = torch.tensor(np.array(states), device=device, dtype=torch.float32)\n",
    "        qvalues = self.forward(states)\n",
    "        best_actions = qvalues.argmax(axis=-1)\n",
    "        return best_actions\n",
    "\n",
    "    def sample_actions(self, qvalues):\n",
    "        # sample actions from a batch of q_values using epsilon greedy policy\n",
    "        epsilon = self.epsilon\n",
    "        batch_size, n_actions = qvalues.shape\n",
    "        random_actions = np.random.choice(n_actions, size=batch_size)\n",
    "        best_actions = qvalues.argmax(axis=-1)\n",
    "        should_explore = np.random.choice(\n",
    "            [0, 1], batch_size, p=[1-epsilon, epsilon])\n",
    "        return np.where(should_explore, random_actions, best_actions)\n",
    "\n",
    "    def save(self, path):\n",
    "        print(\"path:\",path)\n",
    "        torch.save(self.network.state_dict(), f\"{path}.zip\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "id": "kU6xcmXLlNvO"
   },
   "outputs": [],
   "source": [
    "agent = DQNAgent(state_shape, n_actions, epsilon=0.5).to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DQNAgent(\n",
       "  (network): Sequential(\n",
       "    (layer1): Linear(in_features=4, out_features=256, bias=True)\n",
       "    (relu1): ReLU()\n",
       "    (layer2): Linear(in_features=256, out_features=256, bias=True)\n",
       "    (relu2): ReLU()\n",
       "    (layer3): Linear(in_features=256, out_features=2, bias=True)\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "id": "p-BvLAjJlNvO"
   },
   "outputs": [],
   "source": [
    "def evaluate(env, agent, n_games=1, greedy=False, t_max=10000):\n",
    "    rewards = []\n",
    "    for _ in range(n_games):\n",
    "        s,_ = env.reset()\n",
    "        reward = 0\n",
    "        for _ in range(t_max):\n",
    "            qvalues = agent.get_qvalues([s])\n",
    "            action = qvalues.argmax(axis=-1)[0] if greedy else agent.sample_actions(qvalues)[0]\n",
    "            s, r, termiated, truncated,_ = env.step(action)\n",
    "            reward += r\n",
    "            if termiated:\n",
    "                break\n",
    "\n",
    "        rewards.append(reward)\n",
    "    return np.mean(rewards)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "DpclrSjdlNvO",
    "outputId": "703485b1-5410-4de7-d82d-0b174de38b7f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12.0\n"
     ]
    }
   ],
   "source": [
    "print(evaluate(env, agent, n_games=1))\n",
    "env.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QZ3nzghXlNvP"
   },
   "source": [
    "### Experience replay\n",
    "\n",
    "We will use the replay buffer we saw in chapter 4 listings. Replay buffer is very important in DQN to break the correlation between samples. We use a behavior policy ($\\epsilon$-greedy) to sample from the environment and store the transitions `(s,a,r,s',done)` into a buffer. These samples are used multiple times in a learning making the process sample efficient.\n",
    "\n",
    "The interface to ReplayBuffer is:\n",
    "* `exp_replay.add(state, action, reward, next_state, done)` - saves (s,a,r,s',done) tuple into the buffer\n",
    "* `exp_replay.sample(batch_size)` - returns states, actions, rewards, next_states and done_flags for `batch_size` random samples.\n",
    "* `len(exp_replay)` - returns number of elements stored in replay buffer.\n",
    "\n",
    "We have modified the implementation a bit to make it more efficient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "id": "NPmQLEDwlNvP"
   },
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    def __init__(self, size):\n",
    "        self.size = size #max number of items in buffer\n",
    "        self.buffer =[] #array to hold buffer\n",
    "        self.next_id = 0\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.buffer)\n",
    "\n",
    "    def add(self, state, action, reward, next_state, done):\n",
    "        item = (state, action, reward, next_state, done)\n",
    "        if len(self.buffer) < self.size:\n",
    "           self.buffer.append(item)\n",
    "        else:\n",
    "            self.buffer[self.next_id] = item\n",
    "        self.next_id = (self.next_id + 1) % self.size\n",
    "\n",
    "    def sample(self, batch_size):\n",
    "        idxs = np.random.choice(len(self.buffer), batch_size)\n",
    "        samples = [self.buffer[i] for i in idxs]\n",
    "        states, actions, rewards, next_states, done_flags = list(zip(*samples))\n",
    "        return np.array(states), np.array(actions), np.array(rewards), np.array(next_states), np.array(done_flags)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "id": "qyVGDlA8lNvP"
   },
   "outputs": [],
   "source": [
    "def play_and_record(start_state, agent, env, exp_replay, n_steps=1):\n",
    "\n",
    "    s = start_state\n",
    "    sum_rewards = 0\n",
    "\n",
    "    # Play the game for n_steps and record transitions in buffer\n",
    "    for _ in range(n_steps):\n",
    "        qvalues = agent.get_qvalues([s])\n",
    "        a = agent.sample_actions(qvalues)[0]\n",
    "        next_s, r, terminated, truncated, _ = env.step(a)\n",
    "        sum_rewards += r\n",
    "        done = terminated or truncated\n",
    "        exp_replay.add(s, a, r, next_s, done)\n",
    "        if done:\n",
    "            s,_ = env.reset()\n",
    "        else:\n",
    "            s = next_s\n",
    "\n",
    "    return sum_rewards, s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hF0wZVyulNvP"
   },
   "source": [
    "#### Target network\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "YnF0xAe7lNvP",
    "outputId": "a8cbb2d4-91f2-445e-fd12-6fab552790a0"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "target_network = DQNAgent(agent.state_shape, agent.n_actions, epsilon=0.5).to(device)\n",
    "target_network.load_state_dict(agent.state_dict())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "p37MMnoKlNvP"
   },
   "source": [
    "### Learning with DQN\n",
    "Here we write a function similar to tabular q-learning. We will calculate average TD error per batch using the equation:\n",
    "\n",
    "$$ L =  \\frac{1}{N} \\sum_{i=1}^{N} \\left[ r_i + \\left( (1-done_i) . \\gamma .  \\max_{a'} \\hat{q}(s'_i,a';w^-_t) \\right) – \\hat{q}_{w_t}(s_i,a_i;w_t) \\right]^2$$\n",
    "\n",
    "\n",
    "$$ \\nabla_{w_t} L =   - \\frac{1}{N} \\sum_{i=1}^{N} \\left[ r_i + \\left( (1-done_i) . \\gamma .  \\max_{a'} \\hat{q}(s'_i,a';w^-_t) \\right) – \\hat{q}(s_i,a_i;w_t) \\right] \\nabla \\hat{q}_{w_t}(s_i,a_i;w_t)$$\n",
    "\n",
    "\n",
    "$\\hat{q}(s',a';w^{-})$ is calculated using target network whose weights are held constant and refreshed periodically from the agent learning network.\n",
    "\n",
    "Target is given by following:\n",
    "* non terminal state: $r_i +  \\gamma .  \\max\\limits_{a'} \\hat{q}(s'_i,a';w^-_t)$\n",
    "* terminal state: $ r_i $\n",
    "\n",
    "We then carryout back propagation through the agent network to update the weights using equation below:\n",
    "\n",
    "\n",
    "$$\n",
    "w_{t+1} \\leftarrow w_t - \\alpha . \\nabla_{w_t}L$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "id": "K-MGjDImlNvQ"
   },
   "outputs": [],
   "source": [
    "def compute_td_loss(agent, target_network, states, actions, rewards, next_states, done_flags,\n",
    "                    gamma=0.99, device=device):\n",
    "\n",
    "    # convert numpy array to torch tensors\n",
    "    states = torch.tensor(states, device=device, dtype=torch.float)\n",
    "    actions = torch.tensor(actions, device=device, dtype=torch.long)\n",
    "    rewards = torch.tensor(rewards, device=device, dtype=torch.float)\n",
    "    next_states = torch.tensor(next_states, device=device, dtype=torch.float)\n",
    "    done_flags = torch.tensor(done_flags.astype('float32'),device=device,dtype=torch.float)\n",
    "\n",
    "    # get q-values for all actions in current states\n",
    "    # use agent network\n",
    "    predicted_qvalues = agent(states)\n",
    "\n",
    "    # compute q-values for all actions in next states\n",
    "    # use target network\n",
    "    predicted_next_qvalues = target_network(next_states)\n",
    "\n",
    "    # select q-values for chosen actions\n",
    "    predicted_qvalues_for_actions = predicted_qvalues[range(\n",
    "        len(actions)), actions]\n",
    "\n",
    "    # compute Qmax(next_states, actions) using predicted next q-values\n",
    "    next_state_values,_ = torch.max(predicted_next_qvalues, dim=1)\n",
    "\n",
    "    # compute \"target q-values\"\n",
    "    target_qvalues_for_actions = rewards + gamma * next_state_values * (1-done_flags)\n",
    "\n",
    "    # mean squared error loss to minimize\n",
    "    loss = torch.mean((predicted_qvalues_for_actions -\n",
    "                       target_qvalues_for_actions.detach()) ** 2)\n",
    "\n",
    "    return loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xT1ndEKAlNvQ"
   },
   "source": [
    "### Main training Loop\n",
    "\n",
    "We now carryout the training on DQN setup above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "id": "MYSmFEHClNvQ"
   },
   "outputs": [],
   "source": [
    "from tqdm import trange\n",
    "from IPython.display import clear_output\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "49oU16Y9lNvQ",
    "outputId": "83cba370-002d-4eb1-8e44-e1e6b3fef8c7"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torch._C.Generator at 0x7f61540e30d0>"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# set a seed\n",
    "seed = 132\n",
    "random.seed(seed)\n",
    "np.random.seed(seed)\n",
    "torch.manual_seed(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ykURTODElNvQ"
   },
   "source": [
    "#### Set up Environment and Policy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "qeJ1t3LBlNvQ",
    "outputId": "b4beb048-a5a3-4fe7-dc44-aebb01aa8b71"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#setup env and agent and target networks\n",
    "env_name = 'CartPole-v1'\n",
    "env = make_env(env_name)\n",
    "state_dim = env.observation_space.shape\n",
    "n_actions = env.action_space.n\n",
    "state,_ = env.reset(seed=seed)\n",
    "\n",
    "agent = DQNAgent(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network = DQNAgent(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network.load_state_dict(agent.state_dict())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "MS8Uun0hlNvR"
   },
   "source": [
    "#### Populate Experience Replay"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "AxLdDvPnlNvR",
    "outputId": "68db15a5-4435-4563-fef4-de1577d1f758"
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'ReplayBuffer' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[1], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;66;03m# let us fill experience replay with some samples using full random policy\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m exp_replay \u001b[38;5;241m=\u001b[39m \u001b[43mReplayBuffer\u001b[49m(\u001b[38;5;241m10\u001b[39m\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m4\u001b[39m)\n\u001b[1;32m      3\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m100\u001b[39m):\n\u001b[1;32m      4\u001b[0m     play_and_record(state, agent, env, exp_replay, n_steps\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m10\u001b[39m\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m2\u001b[39m)\n",
      "\u001b[0;31mNameError\u001b[0m: name 'ReplayBuffer' is not defined"
     ]
    }
   ],
   "source": [
    "# let us fill experience replay with some samples using full random policy\n",
    "exp_replay = ReplayBuffer(10**4)\n",
    "for i in range(100):\n",
    "    play_and_record(state, agent, env, exp_replay, n_steps=10**2)\n",
    "    if len(exp_replay) == 10**4:\n",
    "        break\n",
    "print(len(exp_replay))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "FcpP-b5plNvR"
   },
   "source": [
    "#### Setup Training Paramaters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "id": "o6tIVZ4elNvR"
   },
   "outputs": [],
   "source": [
    "#setup some parameters for training\n",
    "timesteps_per_epoch = 1\n",
    "batch_size = 32\n",
    "total_steps = 50000\n",
    "\n",
    "#init Optimizer\n",
    "opt = torch.optim.Adam(agent.parameters(), lr=1e-4)\n",
    "\n",
    "# set exploration epsilon\n",
    "start_epsilon = 1\n",
    "end_epsilon = 0.05\n",
    "eps_decay_final_step = 2 * 10**4\n",
    "\n",
    "# setup some frequency for logging and updating target network\n",
    "loss_freq = 20\n",
    "refresh_target_network_freq = 100\n",
    "eval_freq = 1000\n",
    "\n",
    "# to clip the gradients\n",
    "max_grad_norm = 5000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "id": "ieVFCG-0lNvR"
   },
   "outputs": [],
   "source": [
    "mean_rw_history = []\n",
    "td_loss_history = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "id": "ODmQP1gnlNvR"
   },
   "outputs": [],
   "source": [
    "def epsilon_schedule(start_eps, end_eps, step, final_step):\n",
    "    return start_eps + (end_eps-start_eps)*min(step, final_step)/final_step\n",
    "\n",
    "def smoothen(values):\n",
    "    kernel = gaussian(100, std=100)\n",
    "    kernel = kernel / np.sum(kernel)\n",
    "    return convolve(values, kernel, 'valid')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "i94ge69olNvS"
   },
   "source": [
    "#### Run Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 451
    },
    "id": "jZTkNNM3lNvS",
    "outputId": "d4fe3425-e3fe-4713-fcc4-ef7759a780c3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "buffer size = 10000, epsilon = 0.05000\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████| 50001/50001 [06:39<00:00, 125.04it/s]\n"
     ]
    }
   ],
   "source": [
    "state,_ = env.reset()\n",
    "\n",
    "for step in trange(total_steps + 1):\n",
    "\n",
    "    # reduce exploration as we progress\n",
    "    agent.epsilon = epsilon_schedule(start_epsilon, end_epsilon, step, eps_decay_final_step)\n",
    "\n",
    "    # take timesteps_per_epoch and update experience replay buffer\n",
    "    _, state = play_and_record(state, agent, env, exp_replay, timesteps_per_epoch)\n",
    "\n",
    "    # train by sampling batch_size of data from experience replay\n",
    "    states, actions, rewards, next_states, done_flags = exp_replay.sample(batch_size)\n",
    "\n",
    "\n",
    "    # loss = <compute TD loss>\n",
    "    loss = compute_td_loss(agent, target_network,\n",
    "                           states, actions, rewards, next_states, done_flags,\n",
    "                           gamma=0.99,\n",
    "                           device=device)\n",
    "\n",
    "    loss.backward()\n",
    "    grad_norm = nn.utils.clip_grad_norm_(agent.parameters(), max_grad_norm)\n",
    "    opt.step()\n",
    "    opt.zero_grad()\n",
    "\n",
    "    if step % loss_freq == 0:\n",
    "        td_loss_history.append(loss.data.cpu().item())\n",
    "\n",
    "    if step % refresh_target_network_freq == 0:\n",
    "        # Load agent weights into target_network\n",
    "        target_network.load_state_dict(agent.state_dict())\n",
    "\n",
    "    if step % eval_freq == 0:\n",
    "        # eval the agent\n",
    "        mean_rw_history.append(evaluate(\n",
    "            make_env(env_name), agent, n_games=3, greedy=True, t_max=1000)\n",
    "        )\n",
    "\n",
    "        clear_output(True)\n",
    "        print(\"buffer size = %i, epsilon = %.5f\" %\n",
    "              (len(exp_replay), agent.epsilon))\n",
    "\n",
    "        plt.figure(figsize=[16, 5])\n",
    "        plt.subplot(1, 2, 1)\n",
    "        plt.title(\"Mean return per episode\")\n",
    "        plt.plot(mean_rw_history)\n",
    "        plt.grid()\n",
    "\n",
    "        assert not np.isnan(td_loss_history[-1])\n",
    "        plt.subplot(1, 2, 2)\n",
    "        plt.title(\"TD loss history (smoothened)\")\n",
    "        plt.plot(smoothen(td_loss_history))\n",
    "        plt.grid()\n",
    "\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "bgUVBbHFlNvS",
    "outputId": "bfa39ed2-57db-4436-e151-1d71b3dfb4cb"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "final score: 407.8333333333333\n",
      "Well done\n"
     ]
    }
   ],
   "source": [
    "final_score = evaluate(\n",
    "  make_env(env_name),\n",
    "  agent, n_games=30, greedy=True, t_max=1000\n",
    ")\n",
    "print('final score:', final_score)\n",
    "print('Well done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "k6Zn443-lNvS"
   },
   "source": [
    "#### Record and Play a video of trained agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "id": "pOs2hDsClNvS"
   },
   "outputs": [],
   "source": [
    "# Helper function to record videos\n",
    "def record_video(env_id, video_folder, video_length, agent):\n",
    "\n",
    "    vec_env = DummyVecEnv([lambda: gym.make(env_id, render_mode=\"rgb_array\")])\n",
    "    # Record the video starting at the first step\n",
    "    vec_env = VecVideoRecorder(vec_env, video_folder,\n",
    "                           record_video_trigger=lambda x: x == 0, video_length=video_length,\n",
    "                           name_prefix=f\"{type(agent).__name__}-{env_id}\")\n",
    "\n",
    "    obs = vec_env.reset()\n",
    "    for _ in range(video_length + 1):\n",
    "        action = agent.get_action(obs).detach().cpu().numpy()\n",
    "        obs, _, _, _ = vec_env.step(action)\n",
    "    # video filename\n",
    "    file_path = \"./\"+video_folder+vec_env.video_recorder.path.split(\"/\")[-1]\n",
    "    # Save the video\n",
    "    vec_env.close()\n",
    "    return file_path\n",
    "\n",
    "def play_video(file_path):\n",
    "    mp4 = open(file_path, 'rb').read()\n",
    "    data_url = \"data:video/mp4;base64,\" + b64encode(mp4).decode()\n",
    "    return HTML(\"\"\"\n",
    "        <video width=400 controls>\n",
    "              <source src=\"%s\" type=\"video/mp4\">\n",
    "        </video>\n",
    "        \"\"\" % data_url)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 392
    },
    "id": "hO3xk6RAlNvT",
    "outputId": "d9cf0433-18a4-4ef5-f331-dd6982ea8db5"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saving video to /home/nsanghi/sandbox/apress/drl-2ed/chapter6/logs/6_a/vanilla/videos/pt/DQNAgent-CartPole-v1-step-0-to-step-500.mp4\n",
      "Moviepy - Building video /home/nsanghi/sandbox/apress/drl-2ed/chapter6/logs/6_a/vanilla/videos/pt/DQNAgent-CartPole-v1-step-0-to-step-500.mp4.\n",
      "Moviepy - Writing video /home/nsanghi/sandbox/apress/drl-2ed/chapter6/logs/6_a/vanilla/videos/pt/DQNAgent-CartPole-v1-step-0-to-step-500.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                                                        \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready /home/nsanghi/sandbox/apress/drl-2ed/chapter6/logs/6_a/vanilla/videos/pt/DQNAgent-CartPole-v1-step-0-to-step-500.mp4\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "        <video width=400 controls>\n",
       "              <source src=\"data:video/mp4;base64,AAAAIGZ0eXBpc29tAAACAGlzb21pc28yYXZjMW1wNDEAAAAIZnJlZQAAaH1tZGF0AAACrwYF//+r3EXpvebZSLeWLNgg2SPu73gyNjQgLSBjb3JlIDE1OSByMjk5MSAxNzcxYjU1IC0gSC4yNjQvTVBFRy00IEFWQyBjb2RlYyAtIENvcHlsZWZ0IDIwMDMtMjAxOSAtIGh0dHA6Ly93d3cudmlkZW9sYW4ub3JnL3gyNjQuaHRtbCAtIG9wdGlvbnM6IGNhYmFjPTEgcmVmPTMgZGVibG9jaz0xOjA6MCBhbmFseXNlPTB4MzoweDExMyBtZT1oZXggc3VibWU9NyBwc3k9MSBwc3lfcmQ9MS4wMDowLjAwIG1peGVkX3JlZj0xIG1lX3JhbmdlPTE2IGNocm9tYV9tZT0xIHRyZWxsaXM9MSA4eDhkY3Q9MSBjcW09MCBkZWFkem9uZT0yMSwxMSBmYXN0X3Bza2lwPTEgY2hyb21hX3FwX29mZnNldD0tMiB0aHJlYWRzPTEyIGxvb2thaGVhZF90aHJlYWRzPTIgc2xpY2VkX3RocmVhZHM9MCBucj0wIGRlY2ltYXRlPTEgaW50ZXJsYWNlZD0wIGJsdXJheV9jb21wYXQ9MCBjb25zdHJhaW5lZF9pbnRyYT0wIGJmcmFtZXM9MyBiX3B5cmFtaWQ9MiBiX2FkYXB0PTEgYl9iaWFzPTAgZGlyZWN0PTEgd2VpZ2h0Yj0xIG9wZW5fZ29wPTAgd2VpZ2h0cD0yIGtleWludD0yNTAga2V5aW50X21pbj0yNSBzY2VuZWN1dD00MCBpbnRyYV9yZWZyZXNoPTAgcmNfbG9va2FoZWFkPTQwIHJjPWNyZiBtYnRyZWU9MSBjcmY9MjMuMCBxY29tcD0wLjYwIHFwbWluPTAgcXBtYXg9NjkgcXBzdGVwPTQgaXBfcmF0aW89MS40MCBhcT0xOjEuMDAAgAAAAeBliIQAJ//+9bF8CmrJ84oM6DIu4Zckya62IuJtAMAAJShQAAADABLJlCWzIByZd0AAABMgA4ofQZQeYiYqxUCV4g4JjdGAVR1y3YAA8tPQA9noLuPLGQEGci4ZzLBt/g83/R86noEDQRS/DZo4dn7RxniT1kDaBILEm3RgjQLYOlsO7xRDQF3d03nB+OiNy5O8iADlBwOOcX3nS0fwouvy+VfjQ8C6urVlye/10uVWD4KWAUqwERTX1lUHv4ag/V+dcqgN9fv+a3hGv3opy+eTbo/899SRDUAkRXpIne/IrsggqI0668QVpZ9JpaPj+ARTdOcV3LTic8KZk84zeWZnAsu3zyUaYwpK3nZVIOX+dQrWlLZe5cz+Jd7QRn2FEHXyEF8FpI6+XrdfyC9GBu5i5mYvqVRNWqIAINt2W3TFK1BzC6qwrCmi1Fs3uY1WSg5Bh38mNMefKUTXL13MaDzBnR9LlWJ7F/IuEpOOPORP0Ppv4VzJXMO6pK8YssJFBEdF64hsMKqksb7732lNFWCX/qeWP6RpNsKkZmI1cGionyOd9CqoiEEAbWFyazUbJpPcspzHcb4kJgO5RBLFrid5Vjz+UzKdeAisU5wI0Ia9t/oRw2hAZiUlwAAAAwAABW0AAAB6QZokbEJ//fEAAAMCoSpEasPKnlz1J3IDWV88IiIQPnzAytbKcBzCbTiyDn4hHmmM6HwpdgnxrvILtP3eMlinhAzZtDbc6OxfB2Tm9gkiVXD9s79ntnJu8/sIHu+40ci04PaffqcDt6rJMOJBUZQP/lyabsNyzx4kIXgAAAA6QZ5CeIR/AAAWtSs3KI45xjs7DIHRMLAGr2DxVf0BpNsltajo9xSKT4Bmcc6hcJrjvPLK0QDQC4VKgQAAACgBnmF0R/8AACPDF2ippVPVFinLC7QA/5FplP2xuoArO0tDx3l5Tb0gAAAAHwGeY2pH/wAADS/bh16ieBBLRL3oJ+j04sN/BNHKSEcAAABAQZpoSahBaJlMCGf//p4QAAAZte6qzn/CyioQACsQbaLJXS2tgEONl+UwjvjWlsQLBLPn2A/MUKVdGVfZkSnT2wAAACRBnoZFESwj/wAACC8oW3ppwshzQOGB1QDJWPa3IWMVqSKmBjcAAAAQAZ6ldEf/AAADAAI66pS2UQAAACwBnqdqR/8AAAUdLIHL/ckAUAgvagVx2bC0xwFlXY4rrcowLlxH2Hsf2JYSoAAAAB1BmqxJqEFsmUwIX//+jLAAAAMABxwjojIdffTKgAAAADVBnspFFSwj/wAACDWmiB4cQeqt5Tj3HNxMlRpjW+fhdrofpwSm9a3jLpmepd7ZKeMrtjnbgQAAABwBnul0R/8AAA0164eM9pkgLN4rZaFCa3vyLYmAAAAAHgGe62pH/wAADTSdJzhEaYjWUfywfwwjxAbENZ2bgAAAAF9BmvBJqEFsmUwIX//+jLAAABnqs0Km12bVO5ssEZsBN7+uOOew8AJkSO2zGzbWQNKN1ce0EG+QnCyi6eROiSrDmN0syISsncjgAxhgNzH6IjC7YDOsUircKBFmOlX1IQAAABtBnw5FFSwj/wAACC8nNmF058YvfJZMQ7U/wcEAAAAOAZ8tdEf/AAADAAADAakAAAAZAZ8vakf/AAANNJ2rY2rSLB9Z+Os7T1iggAAAACNBmzRJqEFsmUwIV//+OEAAAGRnm/cBbzXqu+zw69D69kevqQAAABlBn1JFFSwj/wAACCwKHkXkCdM8I63v9WKDAAAAIQGfcXRH/wAADTXrh4z2mSAs3iuF02laBR6x96Qy3JPBgAAAAA4Bn3NqR/8AAAMAAAMBqQAAAB1Bm3hJqEFsmUwIT//98QAAAwAAQz/hARCUAHIx4wAAABBBn5ZFFSwj/wAAAwAAAwEHAAAADgGftXRH/wAAAwAAAwGpAAAADgGft2pH/wAAAwAAAwGpAAAAOkGbvEmoQWyZTAhP//3xAAADAp8CxJhlX3wpf0l5YqEAALqFKxJLsEM32leolH7tQBtEVfnwSkXuk4AAAAA2QZ/aRRUsI/8AABa8TmynvxnihCBsAONrGjHe1OgghQrRkrYDFYUoVpnZ2PQTb1yimnPFfsclAAAAGwGf+XRH/wAABR/Qwc8bCfgF/FIKgrHOWCDkgAAAAB0Bn/tqR/8AACO/Gs573gqa0vNlKGiVgIZZSBjkgQAAAEdBm+BJqEFsmUwIX//+jLAAAAoIXMPmZzZEsLU6uCeV5AFJb1hahKk22xDvbpryA//PRgXhP5bMxeIWcHHedUiXCQ9kGfg7OQAAAB5Bnh5FFSwj/wAAAwM4UwqxWcgOieHMcIDPLgq783AAAAAdAZ49dEf/AAAFH9DB1LVXmUX0n3SY/WHJnNNb1kwAAAASAZ4/akf/AAADAAOhADfETifBAAAAJEGaJEmoQWyZTAhf//6MsAAAAwAHq1p54Qwlxsu678rt2Au2YAAAACVBnkJFFSwj/wAAAwM5fNK6g86Ub7rziNUkMDD7R+8ze499JUr/AAAAGwGeYXRH/wAABR/Qwc8bCfgF/FG6pCqFL0vX+AAAABwBnmNqR/8AAAUfNNWzMRW2jgS4AjvboI+GgoqBAAAAF0GaaEmoQWyZTAhf//6MsAAAAwAAAwNDAAAAEEGehkUVLCP/AAADAAADAQcAAAAOAZ6ldEf/AAADAAADAakAAAAOAZ6nakf/AAADAAADAakAAABYQZqsSahBbJlMCFf//jhAAAAmr/jJhLllnZoAWNFxQcAZ3n2j4a5xcNr4s+QXl4+e78XNM0ff6oUfjgK6BO0aK1PaZttmmOiVhzt8teKhYe553bqKRqf1+AAAAB9BnspFFSwj/wAAAwM5Mc2jt5ZxJBFcwJpva2m3h8JVAAAADgGe6XRH/wAAAwAAAwGpAAAAHAGe62pH/wAABR801d7biGqD13hmRkw06utRWLAAAAAjQZrwSahBbJlMCEf//eEAAAMAFYuemeZi4Jh0WKgApTFypoEAAAAsQZ8ORRUsI/8AABazLIvEmRN8O1go5BE+cC7qPibMNkNA5SgpODLlfqwMZB0AAAAgAZ8tdEf/AAAjwz4OeNiEB2Lw7OD2O0gcJaj4VWLIEHEAAAAcAZ8vakf/AAAjvxrOe94JtmKxWIR2QWbkBQ/0gAAAADdBmzNJqEFsmUwIX//+jLAAAEYR5EAcLPBtqw4BDpk6Ebcqlv2+zxp/z5gsCwygA0B/9QCaq4OuAAAAHkGfUUUVLCP/AAAWtVmTJ6+MdWDzrHjxNGmQ86yebwAAABsBn3JqR/8AACPHxrppv2j70y3bHuLkiB0LKLgAAAAZQZt3SahBbJlMCF///oywAAADAAdJGRTypgAAADBBn5VFFSwj/wAACHFPgOfQCQHB5IAAOLQI8VeS0NQdEYb4Lk0+wypLwNiaUt6PkYEAAAAbAZ+0dEf/AAANfhSV9ubJgFvCOMGHcrYpFg/pAAAAGwGftmpH/wAAAwC5op4bRM8oBHiYIHihgQPfbQAAABdBm7tJqEFsmUwIX//+jLAAAAMAAAMDQwAAACFBn9lFFSwj/wAACHFPslhcixnJGPkZDCSzrUeNy2MzYsAAAAAdAZ/4dEf/AAANfhSV9uOvwKvm9FUgGn/PxZwKxYEAAAAbAZ/6akf/AAADALmina4kzygEeJggeKGBA99sAAAATEGb/0moQWyZTAhX//44QAAABYUQ03+QyL6AEnUDZ+kFjGGLArUPzqMqa2FcbpcTISUopcdNbweWoth4kdRQ/7w8st1WO6mhIvSQFoEAAAAeQZ4dRRUsI/8AAAhxT9TkqMZooMFw008nCI3IvoTBAAAADgGePHRH/wAAAwAAAwGpAAAAGwGePmpH/wAAAwC6J70OHUHKx+2fhRYEujCEwAAAABdBmiJJqEFsmUwIR//94QAAAwAAAwAxYQAAAB9BnkBFFSwj/wAACHFP1OdTdLnzHImb7ZepAxng0JgQAAAAIgGeYWpH/wAAI64zBQtDM3Ui8raT/68RnX6IYu9EoAPTQmEAAAAtQZplSahBbJlMCF///oywAABGAtPeAXpj/I9vl2NoEOmToRtyqW/b+jVk0FXAAAAAJEGeg0UVLCP/AAAWtVU0pJX3LZfAFBj/BXdtnhH0vLZzDWp7gQAAAB8BnqRqR/8AACPHxHH0yndEYN37J9Ufosq+p2MaKeYFAAAAJUGaqUmoQWyZTAhX//44QAAAZ37nCAFsWdtxzWC8B1dKBSiIQcEAAAAhQZ7HRRUsI/8AAAhxT9TnrHr7GUt6xx739JmDZ3jWLH+zAAAAGwGe5nRH/wAADX4UKqoszFTcigM4Uqqu8I0JgAAAAB8BnuhqR/8AAA1ejgyoqrylAiRVTZv8Dn73seGGuVwIAAAAF0Ga7UmoQWyZTAhP//3xAAADAAADAB6RAAAAFEGfC0UVLCP/AAAIUnCRU5HYgzVgAAAAEQGfKnRH/wAADX4T7VPt+H+AAAAAEQGfLGpH/wAADYSeFQ3w1mrBAAAAT0GbMUmoQWyZTAhf//6MsAAARgLT3gFyZ8VgeysI79ly4kY6qr4jF7j20TJXfjol4T8oFFXXE7Yr/C2MpwTt/SqDfBRRF1E75fXKSk9o9IEAAAAdQZ9PRRUsI/8AABa8TqFBeFk6sHNkbC0cdApG4sEAAAAUAZ9udEf/AAANfhLzJY+P9AFZ22YAAAAWAZ9wakf/AAAjsisHEzjdH5ia60s3FgAAAB5Bm3VJqEFsmUwIV//+OEAAAAVjub9wFvH1cn3tJL0AAAATQZ+TRRUsI/8AAAMAcUBzRzE0/wAAABIBn7J0R/8AAAMAtYuAVZz81YAAAAAOAZ+0akf/AAADAAADAakAAAAXQZu5SahBbJlMCE///fEAAAMAAAMAHpAAAAAxQZ/XRRUsI/8AAAMBNbDGbyEFuIWEAAr/LtrWTXDZ6nm4HUhrb0ECjrRxWRLTX+z7YQAAABsBn/Z0R/8AAAMB5YoeZLH2vFlFHeWxfLUUQmEAAAAcAZ/4akf/AAADALonin695kxoj6ve/KzXBT5CYAAAAFBBm/1JqEFsmUwIT//98QAAAwAjpr6LuZrVCQ3ILjPoBQuzf/ZjajfzAE5kbLjzXRKjfCUTRcvwDlgFxHZdFxpnligucKbHEWKenS7cuuP+BwAAACdBnhtFFSwj/wAAAwEyfeR2CnCAGfB2SGjrFgx8Eh4Gz6k+qoCEqxUAAAAbAZ46dEf/AAADAeWKHmSx9rxZRR3lsXy1FEJhAAAAEgGePGpH/wAABQ4RzP6zvktJDwAAAC5BmiFJqEFsmUwIT//98QAAAwKfAsSYZTyU+V14rBpWXmuC+v/wATguh1HKlFxAAAAAN0GeX0UVLCP/AAAWvE5sqHncrmhSbWpgVywGAG5aMweOpL/EQJ6SuzNVPbd95Kl3vEimPiTCsosAAAAiAZ5+dEf/AAAFHFt5lulXeJToPY/hwHCLbWoyGr+mKPh7gQAAACABnmBqR/8AACOyKwcTOOGrlvVjg5wG1nKctijejzxFgAAAAC9BmmVJqEFsmUwIV//+OEAAACbe4uFaodASXgAHFSAgJbXvH9urAhRvhm1/bqxV7wAAAClBnoNFFSwj/wAAAwE15ObMLYUnDUoQ44SZx4aAA4aEzhBvVCcdxDh7gAAAABsBnqJ0R/8AAAUeNVUM+LW9gjapklxp8RVf3uEAAAAVAZ6kakf/AAAFHT5g4mccNXKKDUwfAAAAGUGaqUmoQWyZTAhP//3xAAADAABHUebPEXEAAAAfQZ7HRRUsI/8AAAMDOXzT7RsasiA6DUmIkFBD2IKOCQAAABkBnuZ0R/8AAAMB5YoeZLH2vFdCPcrfe8tSAAAAGAGe6GpH/wAABR0+YOJnHIY6Mht4WdXIsAAAADpBmu1JqEFsmUwIX//+jLAAAEgCz1ehQBPg8nK02ZbSuvyWN+rIJJotxh4phYRfdUZHfdXTRDElpLCBAAAAI0GfC0UVLCP/AAAXRSs3a1sgkRqV+LnQbqrVUgD3X7I6wb3uAAAAFwGfKnRH/wAAJMMXaKmlU9T7wnbAc+esAAAALwGfLGpH/wAAJMe9ihymaTtxDSiGwAoNhPaK+6oCoBO/uV02D15dODy5JzBvN3uBAAAAFkGbMUmoQWyZTAhX//44QAAAAwAADKkAAAAjQZ9PRRUsI/8AAAMDObvrp1iCstVxpmLyza4F7kdMRA93rXkAAAAbAZ9udEf/AAADAeWKHnr6NhaSj27Y39DwsHuAAAAAGgGfcGpH/wAABR0+YbdkZ20XCcm+/tu1akWAAAAAF0GbdUmoQWyZTAhP//3xAAADAAADAB6RAAAAEEGfk0UVLCP/AAADAAADAQcAAAAOAZ+ydEf/AAADAAADAakAAAAOAZ+0akf/AAADAAADAakAAABOQZu5SahBbJlMCE///fEAAAMCsQLw4P0o2gzWb2ZiS3FlJqNwCoR90mlahbBqk8yxXMKYc3rgnjw/X9VROYtjXcR5CJCKxQ/IWcLLW1M+AAAAHUGf10UVLCP/AAAXRSs3a1peuKwOoX2ycXj6CCRdAAAAGAGf9nRH/wAAJKv4W3gSnWgkWDwPtVilXQAAABABn/hqR/8AAAMAv1nAygQcAAAAXEGb/UmoQWyZTAhX//44QAABFPofPuEQf6gBYyqG9GjNeH+wTfxA//1sYDLu27dhU9cMPBqVol/tPFnx9kd606SiENAYVnk5l4egEpE/OqtHZ/s89/piWUsswSjFAAAAIkGeG0UVLCP/AAAXTEPNtxXOHIXYsJITWNQaazfABKWwY4IAAAAbAZ46dEf/AAADAeWKeE6AkYkoc0V5erqC5sPdAAAAFwGePGpH/wAAJL8EJxLJaZq4VlUW5oJPAAAAF0GaIUmoQWyZTAhP//3xAAADAAADAB6QAAAANEGeX0UVLCP/AAAIkw4KAG52pDxyKJ8IGKlR8q9wtO+Lh2La5q+xG21fmJjuR4YHWCo7M68AAAAcAZ5+dEf/AAANfhLzJY+0UwafxOwTAT2BBOK73QAAABoBnmBqR/8AAAUdPmG3ZGdtFwnJvv7btWpFgAAAAE5BmmVJqEFsmUwIT//98QAAAwKRyfbenwwZ29gLzvauAYYt7nc/I1cACrG9ebrQBnr4J6rOjjdLWPZJq+kbvSo1q1RXLN5BxFXwtqIOrkEAAAAxQZ6DRRUsI/8AABYlX58HqIABaicaDycNkn8uQEbZ4VLlCfGFLw63pdwiXM13iehwQAAAAB0BnqJ0R/8AACKsQugcUSaesZABwyxEqsH4uTkAiwAAAB4BnqRqR/8AAA2En5bjd1A/FCcQQFrWGYFAWtmhIsEAAAA0QZqpSahBbJlMCE///fEAAAMCstXt2BPM00EwMcNs9eWD2WrnOSVStk0rO+G5wKRyrdyFpQAAADFBnsdFFSwj/wAAF0UrN1Oz02/LgDBWM2tEBOg1flACW0zpHPog9eHmhTnFs29uD2pBAAAAHAGe5nRH/wAAJKv4W3gSnWgjiBGeuRoD3QvzK1IAAAAaAZ7oakf/AAAFHT5ht2RnbRcJyb7+27VqRYAAAAAwQZrtSahBbJlMCE///fEAAAMCsQKk+neQ/hrc1fCnga7Hq/apwAqb59RkA3En3BDxAAAAGkGfC0UVLCP/AAAXRSs3jbLsqHv8vDC2JYYsAAAAFwGfKnRH/wAAJMMXaKmlU9T7wnbHENSAAAAAHgGfLGpH/wAABSBs1Q2hwteBs/IQSe40amwsmuGRYQAAAENBmzFJqEFsmUwIT//98QAAAwBfad+ygBRhAoxOwzlCbZCU5Bz1omteCWOIjm6As9ubugP/U9wVVmV3DZPUZAMKuRmxAAAANEGfT0UVLCP/AAAXQyu1BbbL0Hs4ADin6HSMkzqmV90oCS1kQGzrq7R3DvQrct+OhCd2fqUAAAAYAZ9udEf/AAAkwxdoqaVT1PvCCY1l4zFgAAAAHAGfcGpH/wAAJL8EJxLJaZsrBHVEVvR5k8qUjggAAAA4QZt1SahBbJlMCE///fEAAAMCsPbYZ4rbiRRffU3/rrrlsJkwR628gBGhMDNwfJ/uwFsT0c64xcEAAAAqQZ+TRRUsI/8AABdQmz9hGpnwBH+sgVPvL97Dq/IbJEBjqPVkFfIPgtrwAAAAHwGfsnRH/wAAJMMXaKmo6OeTwvjQz0PznOBMrjP+M4IAAAAiAZ+0akf/AAAkvwQnEsls6MVSRyO636DeY+ikHSh5RlQPcQAAAGZBm7lJqEFsmUwIT//98QAAAwBifM5PhSlk4mtxj40AEdalseoA63/zDSHaQDz82XwaL69qOjiMddeIW44kUSJuJbUD7vhbbYaqjZ5YMCUnTZiZS+teYhQclgCqLzRnPm+KzBK0k2AAAAAhQZ/XRRUsI/8AAAhjYCrAN6lD7tmIZofg6A4d/nOkMteBAAAAHQGf9nRH/wAADX4VwnQEjEs4z0z5w18ECn9owteBAAAAEAGf+GpH/wAAAwC/WcDKBBwAAABdQZv9SahBbJlMCE///fEAAAMCstXw8grp5SHrhdIIIMhzoLUoVcORMsCc+GN6iFvTuZKNQmL2dIMqvQ5grqjLCJMVq97/h16xim4cmVAYfQrwqBhl8fx437bRYxxBAAAAJUGeG0UVLCP/AAAXRSs3jbLYKyxgBLlimIfgvWagRIOmVe185FgAAAAaAZ46dEf/AAAkwxdonQXsMfsqsZATXBm/j5kAAAAeAZ48akf/AAANhJ+VnLsyR8U3KIplW+zakcjbbQPdAAAAS0GaIUmoQWyZTAhP//3xAAADArHt3X4rYZ36sEALRcOTmK/DmosLLWu63PVsBR5rddHjrR/7b3KNqy4iFkFDegHjcuZ5hvFmtyyq8AAAAClBnl9FFSwj/wAAF0xDzbfUa73HNE9cUOlACv/eID+Gcws4TASiQxiw9wAAAA8Bnn50R/8AAA1+E+wAkYEAAAAhAZ5gakf/AAAkscwJb6q978r5+WW0KeRTHl4709rr9A4IAAAAVEGaZUmoQWyZTAhP//3xAAADArG6ddsNMBVBsAA0dkZrll2FLAWG4jsim/+YhiNCbNJwYn7YhMF8tDiV/t2S2u/0ekPq5+uxHAjeedACYPD8QUaovQAAACBBnoNFFSwj/wAAF0xDzbcVzKyZhf0/3k3PAHnkFgBRYAAAAA4BnqJ0R/8AAAMAAAMBqQAAAB0BnqRqR/8AACSxzAlvqWqNqzQGkQKSnMdkHASmwQAAAGZBmqlJqEFsmUwIT//98QAAAwKxunlvg74DCNAYN2sBebFePq1xAVbEhyXJXGmrBIF9/M0hAgpogVJInLdQwHXOohtsssNIdEKpiKm4ghaeFizO83SRiBFg1nD8wW5rShBQYXsmDkEAAAAtQZ7HRRUsI/8AABdMPS5jYMqtBGgBpvVSb7fczY/DbLc8oGiIjWYQKwIKxWpBAAAAHwGe5nRH/wAABUBbeZwn/KDcVvUJxlzvmBvHE/g/SLAAAAAYAZ7oakf/AAAkvwQnEslpmrhWUx+NoDUgAAAAV0Ga7UmoQWyZTAhP//3xAAADArG6eatRv0Qtmbx5VM1JbkZGuv0VVe3pt7Q1tCFkk8BJBKuX18PPJCgG5+y8PV3ncA0Tz7CdSB5fuTXV3E5qUToV9wE2MQAAACRBnwtFFSwj/wAAF0xOav1stN5xtke1Tlo7S3nsVNniZO3brUgAAAAQAZ8qdEf/AAADAEVYeKC2gAAAADMBnyxqR/8AACSyI2a7BGxUkAF1AHUajlGnHkYIS6otox562Ptr70daVtoGBK7friPpWvEAAABOQZsxSahBbJlMCE///fEAAAMCsbp5pdDm4Y5AAufG33RL4xpSYd5IwoQXgoE/eCwWQgO0hu9CfbPmh+smYwUmZFcKr3+bKpWh8qGp/67hAAAAF0GfT0UVLCP/AAAXTE5swthLC0qc/C8hAAAADgGfbnRH/wAAAwAAAwGpAAAAFAGfcGpH/wAAJLIrBxM44agjwH5AAAAANEGbdUmoQWyZTAhP//3xAAADArG6eaXQxellQACIi195mbXxpZ+UGUlKM8rJf6L330lqsi8AAAAlQZ+TRRUsI/8AABdMTmyzJZnbWTkInB6PiULgnHJ7HYHvqi5KbAAAABkBn7J0R/8AAAVD0MHPGwn4BfxRu1LSiIakAAAAHAGftGpH/wAAJLIrBxM44agnIa+gJOjIBF46+pEAAAA+QZu5SahBbJlMCEf//eEAAAQ0uXRsXJN+o1JOw74y0km1pEDQE5ImpGCD34UZqa/pdYTqz5XR10/eLvGKb+EAAAAlQZ/XRRUsI/8AABdMTmxuY+y5gOe5idVbCiQgCfPXkxNPxiQGpQAAABwBn/Z0R/8AAAMB8bGw8Y2QiRUWvHzcFY1ftLuBAAAAFQGf+GpH/wAAJLIrBxM44amQ3qHvQAAAAFtBm/1JqEFsmUwIT//98QAAAwLC9thnit+JPYACWpUn1e0A69pmwp4lGuFl24rNXy98aeMJ03g8NxmofdlsMPfxoU+cQ0WwMvKtFvZZZxfrPOZKqwEy7zVJQvw5AAAAM0GeG0UVLCP/AAAX6X0uY1IyYxW4AAbqNRcLWm6T+06w1lrCpRnAGaZJ9/7tMzHamMUFgAAAABYBnjp0R/8AACSsOQWuTx8/FY1nAUk5AAAALQGePGpH/wAAJbHMCVM/UgVZHMqJf4ABbE7oj9rFNdxYJdtLd324YUJbHCStSQAAAF9BmiFJqEFsmUwIT//98QAAAwLDAvDgjfP5oYwS35ADN5NSFD1Gv22K4+nMc/UJkAw1ObMdH7hwewrJSXAOfHCjGN9s6xcV7wLTw4sZNdhfcozQCIcaskwVETMMub2qwAAAACdBnl9FFSwj/wAAF+mDzbcWgzNlChwrMR4UDdXZ9AuFPfNZzDR2CQYAAAAjAZ5+dEf/AAAFZFt5nCf8jmboA8brwb2o61Xy4rKb2c6TZ8EAAAAXAZ5gakf/AAAlvwQnEslpmrhWVRbmgj4AAABbQZplSahBbJlMCE///fEAAAMCxNQWrNEANW6APgOgGAAlqVH5HtjRKmNgcOhqeJLGbdA5kM+2EHY2FLQw+uios2sGPAnoc15Is78xPHeQg4XymTSIT9AIXelZYQAAAERBnoNFFSwj/wAAF+CHtw21LzDUaO6hCAKzjQei6CceQmmv20HBubia+4f0do/ASpNjTu/lRxhH6UmdMFUVBkVI0S3Z8AAAAB0BnqJ0R/8AACWr+Ft4E+//2K8D9N8U8MqNLf5SYQAAACgBnqRqR/8AACWxzAlKfBlvpSOG68pr/xHHFSTDpyg2ZpYWmzthfkGBAAAANkGaqUmoQWyZTAhH//3hAAAEU3Nj77oh54LnTik9A5kkCnj+xODe0B8sihcjCs656PvAwQuRnwAAACRBnsdFFSwj/wAAF+mDzbe1P1FRQrnX6hpIwIh9oBPTairK7PkAAAAdAZ7mdEf/AAAFZ8vtFTZymxiBe7dZzDR+pbEo91gAAAAvAZ7oakf/AAAlscwJb6lvshVI/38iGptpx6wT+UgQAtZvYEZlMUhAA3n29xDAFnwAAAAuQZrtSahBbJlMCEf//eEAAARTW8ChJAV99/WOU2B1dLoIrMO/wZxOa3jpEkQLwQAAACRBnwtFFSwj/wAAF+CHtw27Eb79hiGs2o8QT4YiT1xNiQMktOAAAAAgAZ8qdEf/AAAlq/hbeBmbsxBZ7YbPIRpB8bq3Vbqd9nwAAAAYAZ8sakf/AAAlscwJb6lvshVJAFY4eI+BAAAAL0GbMUmoQWyZTAhH//3hAAAEU1vAm/OcWL119AzIAAIydOHcCC5HJ/VjcbEUzvxnAAAANEGfT0UVLCP/AAAX4Ie3DcOKAEtM7WNwP5HvrCQGMS2sdn6vJDVJxEU/dvpzwvx9dx+DbTkAAAAiAZ9udEf/AAAlq/hbeBKdaCOIEZ65PCcUApDJZZO0TKD78AAAABgBn3BqR/8AACWxzAlvqW+yFUj7zsJ7EvAAAABiQZt1SahBbJlMCE///fEAAAMCxKwfZGHfC5h2kC9vY27OjrWEmTtkfsvWyaxD0ZeLaONPF/vAhiSw2DDqzqs0YVUUgGkG28TO1DpSoLcxTjQNTEN7ojnj1onqxLqG+YZvqR0AAAAyQZ+TRRUsI/8AABfgh7cNtyTRFVYJpUppxAGlQbol4uW7/CDbH53jH1zjs5QHOdFwdoAAAAAuAZ+ydEf/AAAlq/hbeBFYzcIg4EYbDuHuYiICpqcNI8gk8zKOR4ngAtqCkzy2fAAAACcBn7RqR/8AACWxzAlgSEVgAlEUBbIzhut/JwnvAXQ++HoiZU2OB2kAAABMQZu5SahBbJlMCEf//eEAAARTW9G2nOf4PF+/o10KDK7mt/OMtJZDU48pFxQDNsJPkbq/lPdXcfgBXieKUSN3bw/001CPYaiFg5ZegAAAACxBn9dFFSwj/wAAF+CIklBUdiDxK2wfS9jqwtYQEUnKFAhK5gzugl+Ohi1UmQAAABgBn/Z0R/8AACWsOP70kTmF8SC7GpEA0IEAAAAnAZ/4akf/AAAlsi02RMSAeoGBv4Wb/twbz+ALedDLKaiBqwYoiqzAAAAAS0Gb/UmoQWyZTAhP//3xAAADAsLozvgBFmgC4jTqlGhdvz8Nm3pGHyi6l/TMVfxCIcvcO0SSazbLoos5HfW/p1mKyJdvUiyhn58oRwAAADZBnhtFFSwj/wAAF9/sj7z7gAgv12rt53S1yPx4TFSgL9hD6Iu1M6AqlqS6Wc2KYryn3Fn2QGAAAAAlAZ46dEf/AAAlrDoNPaWUCcGJ7PK5N4hCk+DscFYKSoIivQKUmQAAAB0BnjxqR/8AACWuX/s4Qkt/BJqhzg4Sw2E3aWN6GQAAAFxBmiFJqEFsmUwIR//94QAABHNbtGNtl0DIPgu0JUOpOU3/+2ORM6HhthPE1C7jLHrGNEnxGicu/kc5sBfwj0NIMm7JcIaVS4qfbMiFUq/ldDGbw1Kp+Nv7dPzHMQAAADVBnl9FFSwj/wAAGICHtw25HK6yU/x7TAAA3URtO+oyuIU4mRMz+SIjChQPlnGD4jwAwNWFOAAAACsBnn50R/8AACar+FwpmYn3Natv9avIqiGxX/MDUk2dTzIXoI5sWL6GZnExAAAAKgGeYGpH/wAAJrHMCW/nDSR4ZxYm0LbgBdReeDDuFW1xpu33TN2F23N6wAAAAD1BmmVJqEFsmUwIT//98QAAAwLU6MfDzRzCz/hy577PfvJFEVwBxQ7qjxpc3y6X5gtxAAwQAXYzi/BHqv1BAAAAK0Geg0UVLCP/AAAYf+votDzbgAA13JwdPzYXFhqyyrksGNP9EmD+cKX2mvAAAAAhAZ6idEf/AAAmq/hbeBdEDeainixwUAPKDEguF3iRXHuBAAAAHwGepGpH/wAAJq5eM4F5Q7PNtkBlJyDsQtJJzosvZUEAAAA6QZqpSahBbJlMCE///fEAAAMC1e1A/8x61UxYTIM+/D/Q2wUJmBVTSOVKNedaN510BkPXvNxWs0gDewAAADtBnsdFFSwj/wAAGH/sHqMbRwv5dI79URifsMHrf6VgvPbEPMHniA1UYATLAC7y4TolbzyzNPrf7XWu4QAAACIBnuZ0R/8AACar+Ft4Ep1oI4gRnrk8JxQCkMllk7RMoPtQAAAAIwGe6GpH/wAAJq5eM4F5Q7PNu5hluhKAjB2ke+1PUVVgb/cIAAAAmEGa7UmoQWyZTAhP//3xAAADAtTo3PQCu/hImrUAnLm1LyB1Sjztm9jzWKwM/O/NNx0t34MKPN+IPpWLQGnRYlW+mzxvYGJwCPkaJShRcfhSXeyR2dXF9iumo40S/3rwOhZJ3vg2lnFjHj1U7jkPtqrITrN/hUxz45hRIaEcPrjR/r+CcSxBVISFwrjscsXCygmkdPNWnGbtAAAALUGfC0UVLCP/AAAYf+votEm3AU8nHFNAAE7LZEF7g47cH496HKajmy9FiBxrwAAAAB0Bnyp0R/8AACbDF2ippVPVBHioURyxIAADYasTXgAAACYBnyxqR/8AACauXjOBeUOz3BTdnlgB+Nnm0/mCCr7Xl1yz63LKgQAAAGVBmzFJqEFsmUwIR//94QAABJuiamPqwoxvR1dJiCjiS0UAVgvZi2EGzD/i3fDHzOt5p4hbG7KfW2fYau162+D5LYtLKwzgtl8se7Jn7xJtWoinrbQvxDLb6PFQT+7TqjlqjNyaMQAAAEhBn09FFSwj/wAAGH/sL1oviXc214IBfZQAtmsTC12uOfljVkoBBuIcvhUdT+GU6R0EXt9EsVYkAcb60ESUxaSDzLfMADYqHPkAAAAiAZ9udEf/AAAmwzL8ZQan8KcJw+fFGLTvC3qPoQ6gwcII9wAAACMBn3BqR/8AACauYAULQyERQQO9VePwak2gN2wC27UTnn5HzAAAAGZBm3VJqEFsmUwIT//98QAAAwLm6MlXULBjeAoxjZtG78GWnKhTmQ5M5l++uUR/1ImtuIABbRlnZE/c88m18/yK9SxqNlx3gVy7km5UeH2wqN2uk9EjJSbEwY5UC5IYSOjfpIwhPIEAAABNQZ+TRRUsI/8AABkpfS5jWhrN4J+QCZSy/7YyVzkKQ8JfJdfT1fg7gtC4wNoR/fttM8AJCPyZwMd2H5nojK4qWJkB9iY/n7ReKypLL3AAAAA2AZ+ydEf/AAAmwJqNf8+eKzDwcwcgDINDMdWCUghtOYm4nqpzVeAATKoTJOVXGHsJ31XJhoNeAAAALAGftGpH/wAAJ8mAfzgGoVO+uYKXWeOKwRb7qwPWd66xJR9NoJfxA7cvD02VAAAAZEGbuUmoQWyZTAhP//3xAAADAubtF9G1LK7JiXnuI3rk5PtgdQAvYjQBbR8PyknZ8+1TPHWQyU0xFYpLZqYgZybzy/YFqszVXL6mlyBvQAe9STP0RLyHlRpNAnznVc3/zQTuFoUAAAAsQZ/XRRUsI/8AABkf7B6jJLzx4skM/fY4ZKEojGVDE9F/TZADwDegcLaAe4EAAAAkAZ/2dEf/AAAn21cmKFbJroNyB44S8OxA+QSvAVnA12kx+buBAAAAHwGf+GpH/wAAJ8VT0zx6hlSE5kBmGmmBZONVfqzuG2AAAAJVZYiCAAv//vau/MsrRwuVLh1Ze7NR8uhJcv2IMH1sJ+wAAAMAAAMAA3rZHJsmhGWdpAAAAwLmAIWElDyDzETFWKgTVsvgnF+ADIRdAgU7hHAKOnrD3xuQUUNBdTArGNtLWx3l+Gg9XvRmZuyTqAdY3X6JlPX7sCe37VMenVyJTtzS1RRae5W+LRhLowTyxgEYuw47OMgW5u9c2XtE8wA7ZIXscfWdwigZfZWOCWQNQYCmfrolU78kO2inmZINIQbYBT5NulVhOHHfH9iadz6jRX84Y1JnKN4Re5HhmluAtCGRjYGPDQZm4NcJkEV4CMOZzu3Sw/fqpa+JHuEgKrA1lYYiRBACEyELBVoyeJedt7VxQ3/1x4fnzuxm87pEimvtlY7NwArt0fGilgtrJ0VkZDdR7Bv1YztqHrzc6RZfByRW5OKzvuddnr1lmi857tta+yo0E2PXDMFY5HfCPbqyatnr7JXNNoMzwauAkMDX1g5FE/E2nE8SJfIjmLmgKj8tqNieTZ2wXWi5PvJs+p2oYyIHybhQcugtT40qrUVFB6QR0MnSg6ZPvSGAy+0hhRi0dJU0GEnm391DKwdKLUcuvi2gXLCdi38o2g2P6093OZ2To5bPqS10mW9ss22+F+nS0W7icBJhbo0v9Mxise+o3NFOUpMHOZwLuPwRGVugjUAlOa2Hn6GAhqWTZGkKwekOZxKzxdYHywFQmpUuUvDIUAGuZLftiTEXWB/fqBJW8RQuATNQdl1YGO0N3NX12DeIGkb48SUQyWDChBp0AAADAAADACAhAAAAUkGaJGxCP/3hAAAEk8XBmIJnwHqYO4ktwAV9QJTiKNKxpEA/eLiBo9MCHji9TFpAaJMh4P02ld5xv9P6bia9TPXEPZDzoTmDvtlp0+JfI6mtBYAAAAAlQZ5CeI//AAAnqTuD+TwSBKlJQK4p38ziixhmIlm/QUivfvGzTwAAACABnmF0R/8AACfAWDUAdQRuE6OQFxCFunpkV/Kj16TXLwAAACIBnmNqR/8AACfXqIWTfmzCANhFCfbtysYxMWTLtsw9PLFgAAAAf0GaaEmoQWiZTAhH//3hAAAElLaNIbzCwIc4aFeRmjaBHLCBLRoqEamV/SPCyC/etc337HYN3hDBECxmchJkHeFpQ883in58BdE1ExIlnBz+lBvTbq0OXOCunnE17gU48AFAjfF6ijzQFJeQ6e7EgNQ20NfAjABYT2r4viNAUIAAAAApQZ6GRREsI/8AABkom2YGX6FvJZEU/r4POPmXoySNzQE6mkgu22ZDSg0AAAAhAZ6ldEf/AAAn21ZQghVTI0gkp1FKOdaaQVcFqTr8YFjrAAAAKQGep2pH/wAAJ8QaiocLcC6PKQOMrx556sSAhiBIHt4Mpap+OOGHUQ2hAAAAZ0GarEmoQWyZTAhH//3hAAAEs0g76YUgFpRcig1XDNABJ6CyOzdY9Ttb1HlsCQqzBborc1BLIOFV4VRlXRvMmhmz2iW3iG4cR4m9Qb/XEnDad/5mg6P//xQCgAj8EdvVbmpAfmXHNiAAAAA9QZ7KRRUsI/8AABm/6++Up/t9owHMk80HNhCRBg4gUOLAIC2mug72z5hw5EMAw5C6quqqjF9GFqSspjNbYQAAACsBnul0R/8AACj+Web3mTLP3pZmx8qdszrh7dex+zVfbBc6Y97T058+GW2LAAAALQGe62pH/wAAKOVT0zx6hlSE5kKNhXxdM4Y+bZtC3JjjTMSNHjU7VF1ONFOftwAAAGJBmvBJqEFsmUwIR//94QAABLaLs8usk0u6gNfjcCCZ6D3ZW6FLEC24z/Kw5EbpBqJmvpDv8TkOJh7FcGAwBaOm4tUcf2KKnsDacU0emnDBm9iHDjeGCh3Y/k3kPd9rDeOMeQAAAC1Bnw5FFSwj/wAAGcibT/K0o9+J0TCSh4KAvJbMtpue1aHYwOgHwCNox+PANMAAAAAfAZ8tdEf/AAAo+1cmKFbJq7JPs6BmLdLgt2C8qvywIAAAACMBny9qR/8AACjlU9M8eoZUhOfp3R2Sb/sCbSsUVI9sXM29lwAAAEpBmzRJqEFsmUwIR//94QAABLS3FyG7u8PwhG1dW4byHtRMQMHGGx++FcH+5gIHJZOMpaydiSUU7a2o5bx3Y9Z14ukXRHY4Wj5K3gAAADZBn1JFFSwj/wAAGcibT/K1DEMnjaUVIA7QbdIeSt2SkMqXy4v/C9O/DLw/DmTFnUUSPBffbAgAAAAhAZ9xdEf/AAAo+1cmJ2jCftbvG41R/IE8Lkw+Ezc8p5sDAAAAJgGfc2pH/wAAKOVUEEIuaJoBcTZtlhLQOf/6TeNN9AdsVz9Suq2PAAAAO0Gbd0moQWyZTAhH//3hAAAE00gy3+lISc5zLNEAA0iq5wV4NjqsjgZgTlqovekyOuqgxdBE6TuHExFnAAAAJUGflUUVLCP/AAAaaYMWqN+LmIJ1ScBQdNxt0RzjKYLBX+7u8CAAAAAqAZ+2akf/AAAqGWz7lj2u8YzbVZuBLWVUj7vRaBagA+Q54yIJWnND9aGmAAAAXkGbu0moQWyZTAhH//3hAAAE004MvW6Vn6UnPW+qdWq+iSSJKpWhTe0zwudBHyBzRLnJrRtaZmuj+AQjfllYBR6esEkw503jAFcWY6VEwP1iCzM9otKpP7Pv0V+HdeEAAAA0QZ/ZRRUsI/8AABpfQ70LXmngxfNhU9ieZRxUkFkaPOdqi4pbIbN7HkLSyANrhk7KJsFiPAAAACgBn/h0R/8AACobVyYoVsmrslAa12dS3S4q8nnuWOzPYX18NvD/vLJOAAAAIgGf+mpH/wAAKgQZl8kIYOzzbZAZScgvlXnfqBEb9vOWpdMAAABuQZv/SahBbJlMCEf//eEAAATTS+jn0HemgxkJkBsjefOFhGpXRDScUWhIJz153aFoy/SzN+VZz0j/II89/Wk2qqLWnVvXscFPplZNZL01aJjOMwB6KTyQ0U4BqPeAOwKE04OyEQY0wh0jXkhlfiAAAAAxQZ4dRRUsI/8AABpom0/ytKsaZ/X90gADjbnIexUl7/cQC48u8sXbN1cubtBq4i9dwQAAACQBnjx0R/8AACobVyYoVsmrsk+zoGYtzqOa7Vf8o0MK2euPamEAAAAlAZ4+akf/AAAqBVR8DdmdLqnEigzOH6/Rju3SMboZSx8JuPWpgAAAAIdBmiJJqEFsmUwI//yEAAATS25YkK4rtAFguQHQJEcVw02cFzpiPLr0QBux9bJs35/JHxti6btWybkLubrHlqeAJ1nq2PkmQhGd0sRBEgXb2oVEvBQ8l3Qaps4Znxxf5Q0loeI/wdXIlYclhcvnNVqTDtL9+s9MWRdQavZqrhmffVYvYON9hYEAAAArQZ5ARRUsI/8AABsJfHF2E+8hkgMXOl83tSkDQ9jjNqumEIuW1VPUEq1JgAAAACwBnmFqR/8AACs5bPuWEQjnBqjhwhPaGPB9DZmYFOgH7sN1EDsAjr4EeAjLgQAAAHxBmmRJqEFsmUwUTCP//eEAAAT1f5K/SgKbhx1/s0Lqk3N0AoffBprEJxb5hPPxDhsnsFc+Wgo8plPk+gQW6sfj9HQ99DnjWp8/Q2czY7ZA1OXmMBBoMjjtwe6xC2FnZ8yccqnRXAYXtZOPe/SLaTZQvhwnLGoawQ5zSFb1AAAAJQGeg2pH/wAAKyQZl8kIYOzzbZBb3+WD9mUHW2CoF3ppficKu4AAAABpQZqISeEKUmUwIR/94QAABPrahRPwI/QlyDLGxsEsgDJOH1CIuycdevFL0vhyoQI33nDUIzSvFKKRVOb7JFn4vPD+8OPDOiSKSac2JLjgftQx7XPG4nx4zjf3UvdVKtANYtxQ0APzLQEcAAAAKkGepkU0TCP/AAAbCGMr/yeKUAA426jLRWE0VuumGkujabz8Fg9C+3kBgwAAAD0BnsV0R/8AACs7VyYoiFV5DPqkh1eTUl88VHS9VQNo3isioASzi05sQ/GofHlXkGW++ZSUlX19fKlDrXW0AAAANQGex2pH/wAAKzczRVSEeVKQ0BhlgdgjPB8OZA70puvjRvOF1UJiCEPr+B2OX9Yla6REFur/AAAAnkGazEmoQWiZTAhH//3hAAAFG6b/ZgFufNHwJU/5gWLnv3JlGiAGESycYwevA0AVIF3DJqSKIuPfQRdHA8uH6LWneS2pWNf/7+A8aUgaYjWnBNHRblqukrU4mp45smBghXb53NLqXbHDRQtZXiHgLBRKsuEOjr0nyY9ji4eIDAsbYZz9FQgIEQtpQnHUXk1WfGf4cMk3OTMCPJQ38M/NAAAANkGe6kURLCP/AAAbqXxxdhAtStSFUKua9ybt3xLnjmbCDO5E2PGmRSXihS0dO/zQ7v+fKjh2PQAAACgBnwl0R/8AACs6neNa+s+ufqb/v93RNAouR2JFzBuUmbr3V/U+M6jBAAAALQGfC2pH/wAALEQZP99ktHkKhDGtWXYp8U438o10899FogLUuowS8YVZDVvVSQAAAGlBmxBJqEFsmUwIR//94QAABR5NdOKFkmp5f5fyV+HEEnJpP0gGGIpok2gKDJ9p/YeMsREucaf/SWJROS1IEBYOglyFQKumQaSvtbsITmwCAhN9qCkjz5aeKJgud1gukHx1D+qOANvf/NEAAAArQZ8uRRUsI/8AABufdR0LXmngxfNhU9eDATygb2Lzk7tkS3m+zg+sMIw/gAAAADoBn010R/8AACxanY1iHZxZRH6gdSTYP1rpq+VACS8Zpq/FFapgL5X6jnkBp3z1xfwb6e5it/PpciW0AAAAOQGfT2pH/wAALEQaIvWG/CptbPMeQA710e9300MOoABaLtjd6b8HZlnQoSeXFuKAaEkQUVDKGa/VYQAAAHZBm1RJqEFsmUwIR//94QAABT2SYEVq/5eJFITc4UVAQlexvdgO0ZaCNJ9kAA4MXWfQwGCzt/2tYItWfl89M/qAKwXsv+VHDgYtzl8wxkZlupVQwWOqlIpvIOzO9xk3/uNA1N8KId6sN320INcnXGcaQGif+F5gAAAASEGfckUVLCP/AAAcWH+HGqWqwefwcUR4uwTwfSVdW10xbrxthWqN2NaODLw1aHehfoSG+TM6jyFwAhM/NGjpDLBgfOQavWqygAAAAD8Bn5F0R/8AACw/nqCjJAKDgNGx/P3yiwVmyyIjwAkBKHpv9eGEcCFJ7p/HliZ9Ei4+9IK9otzrcejF9FXbVecAAAAvAZ+Takf/AAAtdo6littzmZNSZq7C/tmsOlHgbESyUQV16deEq9iLcQNO5bPEevMAAABeQZuYSahBbJlMCEf//eEAAAU/MWNtQlXiP20TzJmiD0aYUuWgH2EVe+DlMwOuIh97CQGlEClZPhglRiWu8qc4IYd55CRPer1LrxvS91j+UrMY8cl+tXtycZkkHW/o3wAAACpBn7ZFFSwj/wAAHFb3dK92dw7nYe9n2WhYABDhYMvhTDeO/58aH8ZikkAAAAA8AZ/VdEf/AAAtep2NYilN5zMPdnzJ7wq6H0GdXyF3bY0/nbTrkGrvFKhLm5oM9Xx70DV3t4YUkZKGxqDzAAAAOAGf12pH/wAALWQZMnDsXP0MXMldhs0sqr4ZkdG2NMroMRQHsRSw6tZIkALVhArvDzQ82ft2YT1DAAAAXEGb3EmoQWyZTAhH//3hAAAFYzGOikm/y7+hAkbZTv+S4b0UcZQ3vFoWDa1CxCosCNdaeAA4QuIpfO4Kg8g4Ov4elSnBnDw92IJeN43vogMKfV68RkT8b0R+dQg5AAAAMkGf+kUVLCP/AAAdCDqz2gGv/QvKK6AARD5TsnL8BdBA6IFt4LrCw4Ebb3AeY3GW3NbAAAAAPAGeGXRH/wAALV+eoKMkIYFFcL3Sfmgt61fejZMjj3SZRhxFuMD0nG4hMMugAdrEvzPVtDib1r0G0PyxXwAAADkBnhtqR/8AAC6XM0VUhIjjh9s1J2sqxCYgqKOjn3VsHvOehsOqau00UHmpoAJrbCsGHnyvfbsEIIAAAABYQZoASahBbJlMCEf//eEAAAVjMY7lnyDgz5ddDE3sOnf4T9GIQY07e+OSO7Se+pCQchJ1OvDizucgi2tZV50vOGmSvUYBEZejurA9TuqlFSb3iiuAA5PD0QAAAEZBnj5FFSwj/wAAHPx9kgthqmh9o+b9iZqEmYr9A3st+o7ozodv53j2+oZ1ADaLc3BCanFohQ5vC/AYQWcHSDDPGxpMqg2vAAAANgGeXXRH/wAALpqdjWHAtU74TQwv3TnQoTEJT+tdb1KX4uwPBqAEmmDQJ+nzy26v8HqZO6ilrwAAAD0Bnl9qR/8AAC6EGbyZ6uCpgD4Kg2+7zqY7Zf/Yvk84ftHQHHcmw2fU2qs80w07ugogephfAqo60gWHF0uBAAAAaEGaQ0moQWyZTAhH//3hAAAFhZJcwYKVn6UZPCpQkrzYGR44IJVuhfsQ5O/2drs4uaD+YXaaYvviOQ1MpQQ5Dag0H9ZEjV/ADaJKOLui5/BdmvbkHSoPYxApt6F3kUmBJZVEb2R31wKAAAAAOkGeYUUVLCP/AAAduDrTx8+qAFtv3s+/kNjy/niLtFkk2d2id3ZgnZE61DXTwWxVAxSbDeqMMwMIqcEAAAA3AZ6Cakf/AAAvtxf4OhzHg/bOcckAMJYbD9REGNI/DIUpcr6Gkw/inB0ojRuoi7YMSqAOd8sl+QAAAGFBmodJqEFsmUwI//yEAAAVhMUX3+UlFxlb7ijpRpqoXqtYPc1v55d79fNdfJQeoJVBgpMoNFUbEzJEdg2hB8zkxcNYFCkstDuCAYw5dzED8d++HWxh0MezujpXMp13OvhgAAAAMUGepUUVLCP/AAAdrJBviID7JlvYwUOpO2Ah5moam1y0+um8WxdsRX/daoAf3cN0CrAAAAA5AZ7EdEf/AAAvtH4GnQauS4LP0qfhPEhCxVB9dEtfKEOOwlN7SNKtbarddf+RPzT7JmgsQPy6XltPAAAAMgGexmpH/wAAL5gX9mDsDU4LPUH7txZ5WEI01aZoLH+eOlm+I3MXtbH87QrCjzJNuvRoAAAAVEGayEmoQWyZTAhH//3hAAAFqX+ZYsvWG0QPS5KBsqlIgEpvWrkgC4RAitpl0hiQyRrVvegoQCMCGUB8oyejG8wmMlNzQn48cr/SK8yqyKWywKx/MwAAAGBBmupJ4QpSZTBRUsI//eEAAAWpjgy9bo7Ez4F5kAEdcpHAmo98f/OyRqPjJQEYm3/ZbfCo8gA8xqq4AmS+W+ZSiRR6yJqHGQVFIN0W37pnw4E+3ra49P9JXhUi5pGyhkAAAAAtAZ8Jakf/AAAw9xfA2FQBj71rsohDy5By4BQeH1zgXdkNrtag3F4A2/PT+/v5AAAAUUGbDUnhDomUwIR//eEAAAXNklzBglB4ayUtf1SbCgAHyYABVbZdepxZ35kMsYMM8DeIOYEnF7FFVm9c1kK73VrewKg7IIVBNG796tnenKkJQQAAADJBnytFFTwj/wAAHxh6uuFq042kAAboXpvJc5XLgXsT1jF6yJ2QXSvbt/WYba08ATFWOQAAADoBn0xqR/8AADJSUZFKmAMiRQR8ZGqmRvKtuWhuHrCigCuNzRuCTP2lFTorHUORU2nQwc7iwZ3RHqXBAAAAUUGbT0moQWiZTBTwj/3hAAAFzY4MvW6Ug9a97DyP8//YAOWF5vkGguKvtgiYg9OrlywUTz7mCh0QIFKzPTlHs1dac/v9TuKQVfi/hvehRnJ2MAAAADQBn25qR/8AADI3F7b2TkzaAEsp15/fuGy0ti/tGUEug/pOfBBnRdgg8qQVEGnAKQ6pFrdAAAAAekGbc0nhClJlMCEf/eEAAAX0VOc2yXH/LyKImO0X6qA1ErPuHtA3ZIUbJ0QClmnbeU+yOWAA4QckMCySSpYrM0Rlv7glAebYX5T4594P+Wx234nX1rjQE4QtYK3j7W+EcKc5RPc6mgeZpErkD1Sx04lBLwyx9G2cHLTBAAAALkGfkUU0TCP/AAAfyHIRUmC2Y3/L7D6JJ6ABOESAVabQu7dSZDmM8COYtIrFLTAAAAA7AZ+wdEf/AAAyUXz4nPQj0VIhi7Q9vS/wYqgCGjK023rfFxBi1+ycaPbaOTyVJpxmJXj3Pyaj6N4vPIAAAAA9AZ+yakf/AAAzkjt98yYhsLkaYw8+2dNcpHkuRMHjY7y0O8Cl9KQlXJobJ/ME/BJ0FDoiX3xG/8B8Ynk03QAAAGdBm7dJqEFomUwI//yEAAAXNM6P3+UlIdjAAUTa1xOiEn9rPf0FkClQsnTBz0Q7sAUsouu040L9eUGCz9U4ZucuxRcxHLq6OCmhrCw80oOWHO58DUTlQCTv1IOAYJfUjatYPsd8c++hAAAAQkGf1UURLCP/AAAfvJ5kgthtDIhqMCL4AAjLdUygmnUe6TMNqyuSTEZiLKOmXpuXq8tVs3OXk+T0Ykf4lcYVFrbE3QAAAC4Bn/R0R/8AADNz1Yd+Eh8h3OsAurrbdGABOBiHI85u0zYFbvTC9w6z4fQ0sJY8AAAAKwGf9mpH/wAAM3cYGk8vH5LhmUAJLN32ayd8b0P5b8Hp/r8BmNb8tOdoiHAAAABIQZv4SahBbJlMCEf//eEAAAYcP5a13sBpax9Dy5ShwmuKP5/aQANJxHYlZlzb6kIT8e+eE9lkKP+Xu2LF3AdEs7bIRN/B6UM3AAAASkGaGknhClJlMFFSwj/94QAABh3w4gpLbkoACZI477vMi18i5+3IhcmPucetQTQ1KQdtJKYECcDpf4YmnUUzB8HRDRSmagNS892AAAAAOAGeOWpH/wAANLeetvZOY+gvNFUYQXKWssCV42SU3ycnZDo59Z6MjYaoI4GH83HwQdhASJsWh3kvAAAAVEGaPUnhDomUwI///IQAABhwBRYrFL83oK7CANnFCFmHtI3VcUgemRhVeHnewthitqPPye7fDhO7NrbJGLTwzH6kYeGDWuR7VEZKZVUU08z3X9JL7wAAADhBnltFFTwj/wAAIbyFf2zQOf1CTXztdDyONp6xezQDxf9ysy6UbMfjO9ygCvN6k0GhA8Z4F9aTgAAAACsBnnxqR/8AADX3F/g6DpF1m4hJmNCg+DMpl0VF7s0LGUzoJx8ZPEJNqzVJAAAAXUGafkmoQWiZTAhH//3hAAAGREgy3+laQFEp/4u13/2ykAkHDvO798chkcumIRahWBHRA2cMCfqkDclngW+wfD/+jwyg25f10j9D+MjV0tFFWjTfpGvDcWnSaKyxPQAAAFVBmoFJ4QpSZTAhH/3hAAAGbFRdNqLx/y8crupw/tUqmJ74rM6UDNgF9ADk23xPesHy0z/bs+MuLVXR7fy9AF4lAi6B/TQWVPqOeUI+NSWCLFE2sNGwAAAAM0Gev0U0TCP/AAAivIV/eFJHVTmlwh2mCrSnAD2GSx15UkZOljb8pnlxTaUGUbSfH/RA8wAAACsBnsBqR/8AADdSO+7N4bA5OgYhZ5d1tNoDnDQVfO+lLG0xEO8Vds3um8vgAAAAUUGaxEmoQWiZTAhH//3hAAAGbmc+4dDAzEvdNYTI+axEpUYemQZwQ4RCyaSV74/QJSbpPUXyc7hR28blzsML+rsAlt3kqhiLODIE58UxXg6GgQAAADRBnuJFESwj/wAAIqwVBxVvbuNujnJ3Y0DsNh3SFREHbjonvu0TgihXz7mqy5t8SPzxrHYNAAAAMwGfA2pH/wAANzeetvZOQLVfw+v6TcTU9S+/Usbel6lYQx2cAAncK9IMNTz7tbi6VtN8wAAAAG5BmwZJqEFsmUwUTH/8hAAAGa/9M3+9JRDpROjmfh5RO//0ofECUkRa1KbFHwwn8fYdxBA2VbSGJXbzEB223TJAbUj2L+9/nMNNkLabxbaoGdYe2wQWWa6inRpR8B9+ZDWrIeEC0E8akDXhAKvBoAAAACcBnyVqR/8AADiQsxLfdhCKk/TmGi8aKOQWtSKYa/8wb8FMABJePSEAAAA2QZsnSeEKUmUwIR/94QAABpRIrgHDQXGkjOVTsoB2VAp70tzqMaGRoAQJtPG7eMqDzog4Y7TYAAAAU0GbSknhDomUwIV//jhAAAGvPg14GAC54/6yUROomaOvlM+bgkpfOLatmizXN3/f5QZYw8Yxm0LFE4VGGupSXE6dfAPWf5cPmaTSDawIYeuwHKAhAAAANkGfaEURPCP/AAAjukg00SsVzQFkOwz+UyGTIdXUsVBTxSC1otq4faNyIX5wx+CAf4RLy+N0gAAAADsBn4lqR/8AADiChvvnj+neeEReEQFmCoTZqfqbdI8xwghxa+uvesmOwO+v+Ld23WYSwAPNL3qoijMbHQAAADdBm4xJqEFomUwU8J/98QAABBvgGo94wjC94iRF9nUPmhpIYjAoiXf/+p4Y8PVR/b3KFqv8kq25AAAAHwGfq2pH/wAAOKvhpjQYXzPJUIMkYHjKFhYcV7OX9t0AAAJuZYiEAC///vau/MsrRwuVLh1Ze7NR8uhJcv2IMH1oAAaiugAAAwAAzeYnBkeQENUgAAADALGAHIDxDFDAETFWKgSvGXwOdwE4FjMK4aYNPAxZh6+EE+hD/O6XesT1f9A0VZVzRPSr0FmRVM6FTa3WwnbNu8vH0rzW3BfNtTUdKxUBBqgzCAWP23WsnddVIErd6/Tciqs0Q3Zpb/Q+fXPLn+290ZTC+jHDuWNJdgL+Zt9x1sRru4j+VVeoJrG9BVjkJpkEfz/86dZkfW2CWmOExYWswBePQWbL1+0jIj9s1aX7wb/ssiQEkakm1zP4i17MAVc4tlarKr6FlkVCENj+N3iq1I8L9/BX8QX/4BgWTEfL5IWCvKTqy85OHV8lRoY7G+SAqu9WsyTBA7vXacAVn6hrV/vzj6NXp1gGzAfXQTumekn46dxOpWse8T+L/Y2kJa1tgMgDDyVzMhKrLxV0xVd/fGLtq5KjSX9hHVl+SKZoJO+E8ZqB2YNjAkzPCJeobN8ZQxzAjBGubiNnhhzrRUpCOEFJcWT3Uy4uWp6F54bKZNv0QmDSAcBElYeYjXswV2NkvOUalXZJSvvUA9cCzBCnc92uXFr21HFzTjTea3C4tTI0e8P6R2xtOa308RDo021zfQhYBQyrdZFMdP275zcLSbsF0j8IwpBTIxTBpUjNncuTktiDQKdgw1FPH3vzVRt1Cq37kUz9ZzV1lGsFuSfbWw0bPO83osZEuuABspUIZkBXo1r4DrVKe6cHPSNEU67YZ+H9VgVy+6kZOdfsKUlywoMd3K7bAABXQAAhPBAAAAMAAAMAAAMAAAMBVQAAAKFBmiRsQn/98QAAAwKfV+HBGmPmYA+SlbVcsPUFj5XWl5Iz87CiuKHDHEUnmPjMyL6TxZfP1bYZ0nd51OgFDO70eUJy+Vqql7NbYcvzRowcuSnRNkjwNSWDQ988esSR6/cKgqIjmsBG10nwT1gJa4RCsicBPQifjSIUMp6aJ+fozTHxyh19cY/xgpELyRDQ8MQ+5g2vAHajVjlARirksOAnwAAAADpBnkJ4hH8AABa1Kzrv7g8cwpL/0ANndCuM/Bmd1p6fTOVjSv9XCc7cjnl5hG8fvv2SGrBDGY4707vgAAAAGQGeYXRH/wAAI8MXaKmlU9USD6vxuuLenukAAAAxAZ5jakf/AAAFH6iAox9iWL6iwRmJ5VdToURNkAUn/hyL1cb9vCskrquqBGkaO8jkgAAAAKtBmmhJqEFomUwIT//98QAAAwKg1Bas0LiSGSNaRYrNwMQnuQBD1Id1RyDCJjKNVJPbFUUpo+dMLSrds7EmcsWkTPYWCQ0Rg5ZY7VzdJvFSE5yHM/Ygf8pxzbjYPqs3bVMw3xYaE4bV6OCsUVdpccbnVy0UZLUWpDo2X/EbiB3oLpHtyfgTW359/LA7luwUOICYmMWWzKLU2z0/jRAUYUFEsswhbCr6KZOaaoAAAABNQZ6GRREsI/8AABa1Kzi4UneQAH37lpv0UQ91zR1Twgf2WR8TNkX41CXjL8JkmDDcdvAdhgZlPTZsn4FjWg3G75G5MicgNjHu0sdNzfEAAAAxAZ6ldEf/AAAjwJjpWHxB5pkeM7aflVPeVHfwBfK/LY7HyF0vZ6DuR/HZG5hlnQLZgQAAAB0BnqdqR/8AAA0ypwIU36+/HAK6pdDAOMhFVx1LbwAAAGFBmqxJqEFsmUwIR//94QAABBN4PjgHVR+9xJh5pZkw/Tn4eW3ysnU35StQKnvNkPN8/eHEDt0YAoi/B5HWVmom8BoaadfcdJ30Dboj8wJgDytzj3nJ9N8hKt0T6UBsxYngAAAAJEGeykUVLCP/AAAWvEPMx+DGClrRTxnKy/cRydClrwUw0Mk3wAAAABEBnul0R/8AAA0uE++So1ihgQAAABwBnutqR/8AACOxzAlvwAO3mOjH3ACs1S0jWCAgAAAAYEGa8EmoQWyZTAhn//6eEAAARVEOLwVWqQIAaPfH27XXuNGhq9H2uc5Q/JkHcfNVqlOhaQt9tS+l6N0ANxW0gC3UGOcDKFRRvv0DL2xdtpInV+eR6ACswz1l0n1lkrvCrAAAACFBnw5FFSwj/wAAFrUrN2tu/qlqWNy+yOrHFxSlQk8Lf+cAAAAmAZ8tdEf/AAAjq/hbeBKss0NLrTdOBRDUbwCK/eWGJO5d++O9f4AAAAAOAZ8vakf/AAADAAADAakAAAAaQZs0SahBbJlMCF///oywAAAKC2G39XngA9MAAAASQZ9SRRUsI/8AAAMAAFICfliwAAAADwGfcXRH/wAABR41hQBNwQAAAA4Bn3NqR/8AAAMAAAMBqQAAABpBm3hJqEFsmUwIX//+jLAAABqJPjP3YABNwQAAABNBn5ZFFSwj/wAACGwK4CzifO6RAAAADgGftXRH/wAAAwAAAwGpAAAADgGft2pH/wAAAwAAAwGpAAAAFkGbvEmoQWyZTAhX//44QAAAAwAADKkAAAASQZ/aRRUsI/8AAAMAAFICfliwAAAADgGf+XRH/wAAAwAAAwGpAAAAIQGf+2pH/wAAAwHaWPJdnyH0i/FTDXYpFfFO9X4uUPW2YAAAADZBm+BJqEFsmUwIT//98QAAAwANiIre1MXeAWln/1QkvggDETsrPp1Nmk/j4CxY8KWVX1K7RAkAAAAiQZ4eRRUsI/8AAAMBLM/IES49cTcShPXlluXUtygT19m35wAAABsBnj10R/8AAAMB27ImH9mppAE8U/b/x4FROSEAAAATAZ4/akf/AAADAdt/828MPP4xoQAAAC9BmiRJqEFsmUwIX//+jLAAAAMBbg0KGaDDJ0RxgUO8yG5LXqboACU9GyTjFivtQAAAADZBnkJFFSwj/wAAFrNHVO9Q71jSdwA4EmioMbvFM5RQZmlnBNzbcuw38nL7o5JZUU+PlKMuCz4AAAAmAZ5hdEf/AAAjq/hRlz27dNcdjVKagQ1MG74AVOTGpyQZOuFK8GEAAAAcAZ5jakf/AAAjvwQnEslprVkwDllwAEYmhuDzkgAAADVBmmhJqEFsmUwIV//+OEAAAA4mUH5n6YMALZrsI1eccCKXfaOHJAkMc0x1S3xbb0rvzYpswAAAAENBnoZFFSwj/wAACCo/6ozoAiYLoc8xmTDgOMAiybw4OUiE49tGRcZ999MtyAKWTRkpkOxLeO44DGYg2LXvZ8y2KM+BAAAAHAGepXRH/wAABR/QwcVpX/apKxe4XktZga81y2cAAAAbAZ6nakf/AAAFHzCWe4ktM1cKz3oaHwCClTJNAAAAF0GarEmoQWyZTAhP//3xAAADAAADAB6QAAAAL0GeykUVLCP/AAAWs0dU73w1kPdb/n/7hqAIaktJOEIWkpaS/NDmYhPvnEobOy+YAAAAIwGe6XRH/wAAI8MXaKmlU9pSIpQRCQ3AnIJFjGPiun2m0ckxAAAAHwGe62pH/wAAI78EJxLJX4RDWlIxCeB9+5j4ZHsRbMAAAABdQZrwSahBbJlMCE///fEAAAMCn8hqKAFapC3Vymk5Oo+ywgLzpHXftc8opMZLZF7+f93AmlI8CgveuFlETd0Voxfnz7kt+f7BLBf8vOpfDBoGeN2/S0cb9/03EWpIAAAAKEGfDkUVLCP/AAAWvEPNtxXMsDNDkc8Djb3e7+Rv+An7+Mm5gIWIvfEAAAAbAZ8tdEf/AAADAduyJh/ZqaQBPFP2/8eBUTkgAAAALAGfL2pH/wAAI7HMCW+pdm7pM5NLtIxUACRQAlDpHK5ZIvuXXhSCGFfVStuBAAAAgUGbNEmoQWyZTAhP//3xAAADAp/IaQA5x7CQQAHG2bzojlYwAH7kQGl8romhm3tRVUyMuZmj+wV9lwXPeo8bvyA03PUY+/ulz43YK0nWE9amrsuMoHYGeWsImK8ok5AgaY/ihqLvc6iY/ot273+Yr7YJmIo5zo0exIR7v/Ey/t4GQQAAADJBn1JFFSwj/wAAFrxDyo6H40xe8/0ANHaCchJ6KR3vyi9ytgqqMnr3zctjWpYAig1LbgAAABsBn3F0R/8AAAUf0MEBFJV8PCTr3Cwf5a63dt0AAAAsAZ9zakf/AAAjscwJY+Pxv9YllPIyDHVVw0THQIFM6aYxQflmgsj6VIQsAgIAAABAQZt4SahBbJlMCFf//jhAAAENPyPA+AqdFETDMYoDwiUE/qThyaGtIZmepgNpB3QQRW/NmgSLk1YglHhcGT2VswAAADBBn5ZFFSwj/wAAFrxDzbbZbFx5q7kPoNROL8arOYiZQbweap9OPKiy/F0PugSu2YEAAAAmAZ+1dEf/AAAFH8vsvF1tLj34n/2xZU0DFM3UQDA0Jr7X8LZtZcAAAAAcAZ+3akf/AAAjscwJb6lvshOO9eSwd4sffpx4MAAAABtBm7xJqEFsmUwIT//98QAAAwAM2W4/he8wFlEAAAAkQZ/aRRUsI/8AAAhxLQkNw7jXrqqkwbO30OMAhYN0d+SMz3tuAAAAGwGf+XRH/wAAAwHmsbCSI56Hu0UTqtWYZV+24QAAABsBn/tqR/8AAAMB5n/VSX8TcdX2dxiHhqcmO3AAAAA9QZvgSahBbJlMCFf//jhAAAAmp+xJoYRhDGmwj7LdsDvkGOAOqYWXj+vsLpg8n+YxZ4HZauCxl1miUsQmzQAAADJBnh5FFSwj/wAAFrMrtQKE6Q9ga14oYehwwzDAAjIGsu2l32mggKZLORihMcdltHXolQAAABwBnj10R/8AACPDF2ippVPU+8IJjrAYLdbrsEBBAAAAGAGeP2pH/wAAI78EJxLJaZq4VmfjIy6CXwAAABdBmiRJqEFsmUwIT//98QAAAwAAAwAekAAAACJBnkJFFSwj/wAAAwM3cOyUT4Hm0Blz6EwvNqSuyJVcVtswAAAAGgGeYXRH/wAABR/Qwc62jcNX2BFaCJxmV2zBAAAAGwGeY2pH/wAABR801bGTC8/rwBUNX82QRbDtwAAAAGNBmmhJqEFsmUwIT//98QAAAwBf3Lr9tmHfNKGXgCO3TJtLBFAOhyIrAjotGIRY0taql3xy2pq/naB4KAnfHVxmzGK1nA3O1ZnzNXBvlsaCVztkCHcp64ETKKRXrWCo692+ZIAAAAAkQZ6GRRUsI/8AAAMDOTHNI+QkFwdextY9h5NpkTJ6WMjq+2zBAAAADgGepXRH/wAAAwAAAwGpAAAAJgGep2pH/wAAAwHbgBNdEABxtLvrVhWdBzFB3yxONw/1FArmp6+zAAAAdEGarEmoQWyZTAhH//3hAAAEE3PowO0Y5hBAqKrygobJeB02C1jTorHvjxaQ9fZrPeooONh+CnF0lDaAef9wziCKJZf2OM6HmaqoacNkiaxXJV6HspIAYItEVMR3qzyG8LKB77MQ5MN0tkwKP9Eus+HbDNmgAAAAL0GeykUVLCP/AAAWvEPNtxYeemvvjPCGgACJpLSDD99Z4wBBlcpVzGeYAEZPTRtmAAAAFwGe6XRH/wAABRxbeGah4q1XUsJ1EAwZAAAAJwGe62pH/wAAI78EJxLH/RIrsBTRAhGD7fBy1wMOCydsU1SXmz2duAAAAExBmu9JqEFsmUwIZ//+nhAAAEVR9fVwvepNF+/Pxys+9CcNvfw2ur2Vex9czD0Q6wArfllz0VblOokGLSUNb6fyuZ4JFG8Ui+JpAh4MAAAAHkGfDUUVLCP/AAAWvEPNtxXMrLWypUqjfB5XF2UvBwAAACkBny5qR/8AACOxzAlvqKCQ5gEHXMvfoM42bVuF0Clz59RA23/xSdNICAAAABdBmzNJqEFsmUwIX//+jLAAAAMAAAMDQwAAACdBn1FFFSwj/wAAAwM3cMAcEXRZ62Ip/WDQpdQGD2dj70QmXMfjwYEAAAAaAZ9wdEf/AAADAeWKHhmoeKtbqZb8x7Qb34MAAAAZAZ9yakf/AAAFHT5g4G3b8T8RGfkotHMduQAAABdBm3dJqEFsmUwIX//+jLAAAAMAAAMDQgAAABBBn5VFFSwj/wAAAwAAAwEHAAAADgGftHRH/wAAAwAAAwGpAAAADgGftmpH/wAAAwAAAwGpAAAAFkGbu0moQWyZTAhX//44QAAAAwAADKgAAAAQQZ/ZRRUsI/8AAAMAAAMBBwAAAA4Bn/h0R/8AAAMAAAMBqQAAAA4Bn/pqR/8AAAMAAAMBqQAAABlBm/9JqEFsmUwIT//98QAAAwAAP1ertjH5AAAAK0GeHUUVLCP/AAADAyKGSAiSUqlJpbM1UTjc0EugTGgJKsQVX6yHtzGW2YEAAAAaAZ48dEf/AAAE+9DBzz2mSAtw8gVqdqVVkmEAAAAZAZ4+akf/AAAE+T5g4u427FQ31qvf70VSTQAAAEFBmiNJqEFsmUwIV//+OEAAAQ7omtWdERcjVMPAGNtRRLIRmlAU7JZMZPN+HJF1uEZHUjvzR1g2tGF1XaAhIs9BdwAAAEJBnkFFFSwj/wAAFrMsA4GanpN2DNcWa9NEuAHSC6An9jnYzrRsvBOf965pRCVblgQAm//svkwUgC7IBAUQ5WkUWzAAAAAcAZ5gdEf/AAANfhSRdzcPPN2m35QFn4dqz2wnJAAAAB4BnmJqR/8AACO/BCcSyWmauGvtwHeoLcifm9FuSYEAAAAWQZpmSahBbJlMCP/8hAAAAwAAAwDAgAAAADZBnoRFFSwj/wAACGjAteIwAcm7ozYflF067RP5Ui8Ttpvz4VPovIlscyFU2opT2n6s+zErnbgAAAAdAZ6lakf/AAANhJ2qS/ibjqYcBEOmpUBsQfebPg0AAABbQZqnSahBbJlMCFf//jhAAAEM+h3xN4E/LRWcpjaFLyvQA2CmE2GzQHJgvfNph+GCLANwdtDThV+yHQsvSa1eTbAr204Xv/8yx6tlpYEjNr7xjbOjwU/Uk2FVYQAAABlBmspJ4QpSZTAhP/3xAAADAA2DoR9EYBMxAAAAREGe6EU0TCP/AAADAzre8AVvWM/cT/iauXh6HyISVkCIGlie1z6e1vUjAcseycMpQK7GtgiXqpAUWRaJufN4QXgC32zAAAAAHAGfCWpH/wAABR8wlnuJLTNk/qzgAm51UsHiLwYAAAA3QZsOSahBaJlMCF///oywAABGfiY+HkGAoOsf3iJmZzEOqf1pX1zpTVgSsKnrGYiAmT9l9rdAwQAAADlBnyxFESwj/wAAFrUrMNd6ITznsdF6QoB1//vdR1AFHRHiMyzDZ80BEq0bx78UYavHbaATLWR1SSYAAAAcAZ9LdEf/AAAjq/hbeBKdaCOIEZ65GgPdC/MrZgAAABsBn01qR/8AAA2EnRbYOk/6CteXLrlG5JBDEgMAAAAWQZtSSahBbJlMCFf//jhAAAADAAAMqAAAABBBn3BFFSwj/wAAAwAAAwEHAAAADgGfj3RH/wAAAwAAAwGpAAAAKQGfkWpH/wAAAwCzZxLRUNLRdk7ciuSoP+c35TKl94APoU5zR8vF1+u/AAAAQUGblkmoQWyZTAhP//3xAAADAPfzD4Chin9MgH7izh3tEU9dilNi0DQZ2wiNHR2LJnBSHL+FOPLCmxpzzDtoodkbAAAAPUGftEUVLCP/AAAWI0iuOGzZU2/+WowA3LRm3hUwDPMJh/sIcQnyP50vUht5DZNxOR+etlNEQNYJaBJM8GAAAAAhAZ/TdEf/AAAiw0cHNwCiG/KTSod0oinCM7NiRyzwZiQFAAAAGQGf1WpH/wAAIr8fjDe6m4rWnZNhei3qgrcAAABeQZvaSahBbJlMCE///fEAAAMA+Xpuvq8ddGpSVQ99iPQAQeZ+G2r9PA/REm+Y280BJBfb6o+VJnqUqR1kwQaLr/yQ3pQtY13jlVS1XCawvZTswUstKjS1N5eL8v762AAAACVBn/hFFSwj/wAACGwKHkOF/AKkzm4OACCeKp05tOffZ0C3l7ZgAAAAHQGeF3RH/wAADX4S8ySe6txF5pe8CojXCfjBwWOTAAAADgGeGWpH/wAAAwAAAwGpAAAAL0GaHkmoQWyZTAhP//3xAAADAA0tTgRU1Mz4uW0ANRnb0RCfRc7IW6islzFImj6BAAAAIUGePEUVLCP/AAAWI0iRPkzbZ0VlErnnZ44uzjenHF5lgwAAAB4Bnlt0R/8AACLDPg536ze+ESnj0cxxo8pSePkfWDEAAAAVAZ5dakf/AAAivxrOe94JtmKtUKSBAAAALkGaX0moQWyZTAhP//3xAAADAA0tbWr5CBRxQAqxtl9xbaHxErAApDzynKP9xYEAAAAsQZpjSeEKUmUwIX/+jLAAAEQUyjsIDGNcdeKAAde8WWFAdVI2WusktvGQV8EAAAA9QZ6BRTRMI/8AABYsTajZ30ZRoANjjNuW1LPvi/CELg0rUjen969dEefoFusHTRqEkMgbtKdPzxY+TTRuLAAAABsBnqB0R/8AAAT4W3mSx8fk9Lcb2yp95FwoYsAAAAAcAZ6iakf/AAAivxrOe94UHgbiCrnurrka1ClY+QAAAExBmqdJqEFomUwIX//+jLAAAAnD/w8AK2yXvL0yLW8FTzjz/qrDsZGaadyNFI+Wm1/tFxckMGyD64vKE5QaXJenpsgA2LXxfo1JsnSMAAAAHEGexUURLCP/AAADAyRTCrZWDbD5Wgi31frGJJgAAAAZAZ7kdEf/AAAE+Ft5lWfvq7i38Ypc5+xWzQAAABABnuZqR/8AAAMAtfDV2BXxAAAAQkGa60moQWyZTAhP//3xAAADAA0s4wgvgH1ga+4HZRl2BNBFYsTdGEMPei5TiQATN6WQyvCLUxA1dLxE+PitnvFxYQAAAB5BnwlFFSwj/wAAAwMlfNK6gMgoL91kIWaJs+mPEBAAAAAZAZ8odEf/AAAE+Ft5ksfH/8YnsOt6HF0kwAAAABoBnypqR/8AAAT5PmDiZxyHHEyS3h7tSHgrZwAAACJBmy1JqEFsmUwUTH/8hAAAAwAElOPolK2jJs528bCt53PgAAAAFgGfTGpH/wAAAwAKOpvpj9PiKyW2kmAAABonbW9vdgAAAGxtdmhkAAAAAAAAAAAAAAAAAAAD6AAAJyQAAQAAAQAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAGVF0cmFrAAAAXHRraGQAAAADAAAAAAAAAAAAAAABAAAAAAAAJyQAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAABAAAAAAlgAAAGQAAAAAAAkZWR0cwAAABxlbHN0AAAAAAAAAAEAACckAAACAAABAAAAABjJbWRpYQAAACBtZGhkAAAAAAAAAAAAAAAAAAAyAAAB9QBVxAAAAAAALWhkbHIAAAAAAAAAAHZpZGUAAAAAAAAAAAAAAABWaWRlb0hhbmRsZXIAAAAYdG1pbmYAAAAUdm1oZAAAAAEAAAAAAAAAAAAAACRkaW5mAAAAHGRyZWYAAAAAAAAAAQAAAAx1cmwgAAAAAQAAGDRzdGJsAAAAmHN0c2QAAAAAAAAAAQAAAIhhdmMxAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAlgBkABIAAAASAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGP//AAAAMmF2Y0MBZAAf/+EAGWdkAB+s2UCYM+XhAAADAAEAAAMAZA8YMZYBAAZo6+PLIsAAAAAYc3R0cwAAAAAAAAABAAAB9QAAAQAAAAAcc3RzcwAAAAAAAAADAAAAAQAAAPsAAAFoAAAPSGN0dHMAAAAAAAAB5wAAAAEAAAIAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABAAAAAACAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAQAAAAAAgAAAQAAAAABAAAEAAAAAAIAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAAAgAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABAAAAAACAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAEAAAAAAIAAAEAAAAAAQAAAwAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABAAAAAACAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAAAgAAAAABAAADAAAAAAEAAAEAAAAAAQAABAAAAAACAAABAAAAAAEAAAMAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAAAgAAAAABAAADAAAAAAEAAAEAAAAAAQAABAAAAAACAAABAAAAAAEAAAIAAAAAAQAABAAAAAACAAABAAAAAAEAAAQAAAAAAgAAAQAAAAABAAADAAAAAAEAAAEAAAAAAQAAAgAAAAABAAAEAAAAAAIAAAEAAAAAAQAAAwAAAAABAAABAAAAAAEAAAIAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAEAAAAAAIAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAQAAAAAAgAAAQAAAAABAAACAAAAAAEAAAQAAAAAAgAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAAAgAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAADAAAAAAEAAAEAAAAAHHN0c2MAAAAAAAAAAQAAAAEAAAH1AAAAAQAAB+hzdHN6AAAAAAAAAAAAAAH1AAAElwAAAH4AAAA+AAAALAAAACMAAABEAAAAKAAAABQAAAAwAAAAIQAAADkAAAAgAAAAIgAAAGMAAAAfAAAAEgAAAB0AAAAnAAAAHQAAACUAAAASAAAAIQAAABQAAAASAAAAEgAAAD4AAAA6AAAAHwAAACEAAABLAAAAIgAAACEAAAAWAAAAKAAAACkAAAAfAAAAIAAAABsAAAAUAAAAEgAAABIAAABcAAAAIwAAABIAAAAgAAAAJwAAADAAAAAkAAAAIAAAADsAAAAiAAAAHwAAAB0AAAA0AAAAHwAAAB8AAAAbAAAAJQAAACEAAAAfAAAAUAAAACIAAAASAAAAHwAAABsAAAAjAAAAJgAAADEAAAAoAAAAIwAAACkAAAAlAAAAHwAAACMAAAAbAAAAGAAAABUAAAAVAAAAUwAAACEAAAAYAAAAGgAAACIAAAAXAAAAFgAAABIAAAAbAAAANQAAAB8AAAAgAAAAVAAAACsAAAAfAAAAFgAAADIAAAA7AAAAJgAAACQAAAAzAAAALQAAAB8AAAAZAAAAHQAAACMAAAAdAAAAHAAAAD4AAAAnAAAAGwAAADMAAAAaAAAAJwAAAB8AAAAeAAAAGwAAABQAAAASAAAAEgAAAFIAAAAhAAAAHAAAABQAAABgAAAAJgAAAB8AAAAbAAAAGwAAADgAAAAgAAAAHgAAAFIAAAA1AAAAIQAAACIAAAA4AAAANQAAACAAAAAeAAAANAAAAB4AAAAbAAAAIgAAAEcAAAA4AAAAHAAAACAAAAA8AAAALgAAACMAAAAmAAAAagAAACUAAAAhAAAAFAAAAGEAAAApAAAAHgAAACIAAABPAAAALQAAABMAAAAlAAAAWAAAACQAAAASAAAAIQAAAGoAAAAxAAAAIwAAABwAAABbAAAAKAAAABQAAAA3AAAAUgAAABsAAAASAAAAGAAAADgAAAApAAAAHQAAACAAAABCAAAAKQAAACAAAAAZAAAAXwAAADcAAAAaAAAAMQAAAGMAAAArAAAAJwAAABsAAABfAAAASAAAACEAAAAsAAAAOgAAACgAAAAhAAAAMwAAADIAAAAoAAAAJAAAABwAAAAzAAAAOAAAACYAAAAcAAAAZgAAADYAAAAyAAAAKwAAAFAAAAAwAAAAHAAAACsAAABPAAAAOgAAACkAAAAhAAAAYAAAADkAAAAvAAAALgAAAEEAAAAvAAAAJQAAACMAAAA+AAAAPwAAACYAAAAnAAAAnAAAADEAAAAhAAAAKgAAAGkAAABMAAAAJgAAACcAAABqAAAAUQAAADoAAAAwAAAAaAAAADAAAAAoAAAAIwAAAlkAAABWAAAAKQAAACQAAAAmAAAAgwAAAC0AAAAlAAAALQAAAGsAAABBAAAALwAAADEAAABmAAAAMQAAACMAAAAnAAAATgAAADoAAAAlAAAAKgAAAD8AAAApAAAALgAAAGIAAAA4AAAALAAAACYAAAByAAAANQAAACgAAAApAAAAiwAAAC8AAAAwAAAAgAAAACkAAABtAAAALgAAAEEAAAA5AAAAogAAADoAAAAsAAAAMQAAAG0AAAAvAAAAPgAAAD0AAAB6AAAATAAAAEMAAAAzAAAAYgAAAC4AAABAAAAAPAAAAGAAAAA2AAAAQAAAAD0AAABcAAAASgAAADoAAABBAAAAbAAAAD4AAAA7AAAAZQAAADUAAAA9AAAANgAAAFgAAABkAAAAMQAAAFUAAAA2AAAAPgAAAFUAAAA4AAAAfgAAADIAAAA/AAAAQQAAAGsAAABGAAAAMgAAAC8AAABMAAAATgAAADwAAABYAAAAPAAAAC8AAABhAAAAWQAAADcAAAAvAAAAVQAAADgAAAA3AAAAcgAAACsAAAA6AAAAVwAAADoAAAA/AAAAOwAAACMAAAJyAAAApQAAAD4AAAAdAAAANQAAAK8AAABRAAAANQAAACEAAABlAAAAKAAAABUAAAAgAAAAZAAAACUAAAAqAAAAEgAAAB4AAAAWAAAAEwAAABIAAAAeAAAAFwAAABIAAAASAAAAGgAAABYAAAASAAAAJQAAADoAAAAmAAAAHwAAABcAAAAzAAAAOgAAACoAAAAgAAAAOQAAAEcAAAAgAAAAHwAAABsAAAAzAAAAJwAAACMAAABhAAAALAAAAB8AAAAwAAAAhQAAADYAAAAfAAAAMAAAAEQAAAA0AAAAKgAAACAAAAAfAAAAKAAAAB8AAAAfAAAAQQAAADYAAAAgAAAAHAAAABsAAAAmAAAAHgAAAB8AAABnAAAAKAAAABIAAAAqAAAAeAAAADMAAAAbAAAAKwAAAFAAAAAiAAAALQAAABsAAAArAAAAHgAAAB0AAAAbAAAAFAAAABIAAAASAAAAGgAAABQAAAASAAAAEgAAAB0AAAAvAAAAHgAAAB0AAABFAAAARgAAACAAAAAiAAAAGgAAADoAAAAhAAAAXwAAAB0AAABIAAAAIAAAADsAAAA9AAAAIAAAAB8AAAAaAAAAFAAAABIAAAAtAAAARQAAAEEAAAAlAAAAHQAAAGIAAAApAAAAIQAAABIAAAAzAAAAJQAAACIAAAAZAAAAMgAAADAAAABBAAAAHwAAACAAAABQAAAAIAAAAB0AAAAUAAAARgAAACIAAAAdAAAAHgAAACYAAAAaAAAAFHN0Y28AAAAAAAAAAQAAADAAAABidWR0YQAAAFptZXRhAAAAAAAAACFoZGxyAAAAAAAAAABtZGlyYXBwbAAAAAAAAAAAAAAAAC1pbHN0AAAAJal0b28AAAAdZGF0YQAAAAEAAAAATGF2ZjU4LjI5LjEwMA==\" type=\"video/mp4\">\n",
       "        </video>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "video_folder = \"logs/6_a/vanilla/videos/pt/\"\n",
    "video_length = 500\n",
    "\n",
    "video_file = record_video(env_name, video_folder, video_length, agent)\n",
    "\n",
    "play_video(video_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pdqnVVdolNvU"
   },
   "source": [
    "### Train DQN using SB3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "D3BJ9bpRlNvU"
   },
   "source": [
    "You can package the video generated to huggingface manually and share. However to share the trained model parameters and replay video, it involves more work which requires you to save the model weight and upload.\n",
    "Instead we will retrain the model using stablebaseline3 (sb3) and upload the model to hugging face using utilities provided in sb3.\n",
    "\n",
    "#### Create DQN Agent\n",
    "We will create a DQN agent with same architecture as before i.e. with two Fully COnnected Linear layers of size 256"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "xyoZkZ0NlNvU",
    "outputId": "c949f44d-a2b7-4a7f-a4d8-a7d864488406"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using cpu device\n",
      "Wrapping the env with a `Monitor` wrapper\n",
      "Wrapping the env in a DummyVecEnv.\n"
     ]
    }
   ],
   "source": [
    "# create the DQN agent\n",
    "from stable_baselines3 import DQN\n",
    "\n",
    "#define a policy matching ours\n",
    "#define the activation function and the network layers size\n",
    "policy_kwargs = dict(activation_fn=torch.nn.ReLU,\n",
    "                     net_arch=[256, 256])\n",
    "\n",
    "\n",
    "env = gym.make(env_name, render_mode=\"rgb_array\")\n",
    "model = DQN(\"MlpPolicy\", env, policy_kwargs=policy_kwargs, verbose=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XlSiLLlhlNvU"
   },
   "source": [
    "#### Print the Policy Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "o5N-JZbClNvV",
    "outputId": "bb9cc671-2034-4dc0-df81-aceb17d6a529"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DQNPolicy(\n",
       "  (q_net): QNetwork(\n",
       "    (features_extractor): FlattenExtractor(\n",
       "      (flatten): Flatten(start_dim=1, end_dim=-1)\n",
       "    )\n",
       "    (q_net): Sequential(\n",
       "      (0): Linear(in_features=4, out_features=256, bias=True)\n",
       "      (1): ReLU()\n",
       "      (2): Linear(in_features=256, out_features=256, bias=True)\n",
       "      (3): ReLU()\n",
       "      (4): Linear(in_features=256, out_features=2, bias=True)\n",
       "    )\n",
       "  )\n",
       "  (q_net_target): QNetwork(\n",
       "    (features_extractor): FlattenExtractor(\n",
       "      (flatten): Flatten(start_dim=1, end_dim=-1)\n",
       "    )\n",
       "    (q_net): Sequential(\n",
       "      (0): Linear(in_features=4, out_features=256, bias=True)\n",
       "      (1): ReLU()\n",
       "      (2): Linear(in_features=256, out_features=256, bias=True)\n",
       "      (3): ReLU()\n",
       "      (4): Linear(in_features=256, out_features=2, bias=True)\n",
       "    )\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.policy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yjlDzkcHlNvV"
   },
   "source": [
    "#### Train the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000,
     "referenced_widgets": [
      "5a5055a2d85f4f03af3fb9782d9e33b2",
      "da89e5f6ee4c4030a4b43897d12061f6"
     ]
    },
    "id": "Ak-FXqAhlNvV",
    "outputId": "b4dc119d-75ca-4f8b-b018-0261e9674786"
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b58af3393c3b4d15b950051e1c9c4df3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------------------------------\n",
      "| rollout/            |          |\n",
      "|    ep_len_mean      | 23.1     |\n",
      "|    ep_rew_mean      | 23.1     |\n",
      "|    exploration_rate | 0.05     |\n",
      "| time/               |          |\n",
      "|    episodes         | 500      |\n",
      "|    fps              | 12325    |\n",
      "|    time_elapsed     | 0        |\n",
      "|    total_timesteps  | 11641    |\n",
      "----------------------------------\n",
      "----------------------------------\n",
      "| rollout/            |          |\n",
      "|    ep_len_mean      | 22.3     |\n",
      "|    ep_rew_mean      | 22.3     |\n",
      "|    exploration_rate | 0.05     |\n",
      "| time/               |          |\n",
      "|    episodes         | 1000     |\n",
      "|    fps              | 12976    |\n",
      "|    time_elapsed     | 1        |\n",
      "|    total_timesteps  | 23051    |\n",
      "----------------------------------\n",
      "----------------------------------\n",
      "| rollout/            |          |\n",
      "|    ep_len_mean      | 19.7     |\n",
      "|    ep_rew_mean      | 19.7     |\n",
      "|    exploration_rate | 0.05     |\n",
      "| time/               |          |\n",
      "|    episodes         | 1500     |\n",
      "|    fps              | 13162    |\n",
      "|    time_elapsed     | 2        |\n",
      "|    total_timesteps  | 33658    |\n",
      "----------------------------------\n",
      "----------------------------------\n",
      "| rollout/            |          |\n",
      "|    ep_len_mean      | 22.1     |\n",
      "|    ep_rew_mean      | 22.1     |\n",
      "|    exploration_rate | 0.05     |\n",
      "| time/               |          |\n",
      "|    episodes         | 2000     |\n",
      "|    fps              | 13223    |\n",
      "|    time_elapsed     | 3        |\n",
      "|    total_timesteps  | 44539    |\n",
      "----------------------------------\n",
      "----------------------------------\n",
      "| rollout/            |          |\n",
      "|    ep_len_mean      | 13       |\n",
      "|    ep_rew_mean      | 13       |\n",
      "|    exploration_rate | 0.05     |\n",
      "| time/               |          |\n",
      "|    episodes         | 2500     |\n",
      "|    fps              | 5551     |\n",
      "|    time_elapsed     | 9        |\n",
      "|    total_timesteps  | 53677    |\n",
      "| train/              |          |\n",
      "|    learning_rate    | 0.0001   |\n",
      "|    loss             | 0.000165 |\n",
      "|    n_updates        | 919      |\n",
      "----------------------------------\n",
      "----------------------------------\n",
      "| rollout/            |          |\n",
      "|    ep_len_mean      | 11.6     |\n",
      "|    ep_rew_mean      | 11.6     |\n",
      "|    exploration_rate | 0.05     |\n",
      "| time/               |          |\n",
      "|    episodes         | 3000     |\n",
      "|    fps              | 2502     |\n",
      "|    time_elapsed     | 23       |\n",
      "|    total_timesteps  | 59353    |\n",
      "| train/              |          |\n",
      "|    learning_rate    | 0.0001   |\n",
      "|    loss             | 1.92e-05 |\n",
      "|    n_updates        | 2338     |\n",
      "----------------------------------\n",
      "----------------------------------\n",
      "| rollout/            |          |\n",
      "|    ep_len_mean      | 15.1     |\n",
      "|    ep_rew_mean      | 15.1     |\n",
      "|    exploration_rate | 0.05     |\n",
      "| time/               |          |\n",
      "|    episodes         | 3500     |\n",
      "|    fps              | 1627     |\n",
      "|    time_elapsed     | 40       |\n",
      "|    total_timesteps  | 66352    |\n",
      "| train/              |          |\n",
      "|    learning_rate    | 0.0001   |\n",
      "|    loss             | 0.00822  |\n",
      "|    n_updates        | 4087     |\n",
      "----------------------------------\n",
      "----------------------------------\n",
      "| rollout/            |          |\n",
      "|    ep_len_mean      | 93.4     |\n",
      "|    ep_rew_mean      | 93.4     |\n",
      "|    exploration_rate | 0.05     |\n",
      "| time/               |          |\n",
      "|    episodes         | 4000     |\n",
      "|    fps              | 897      |\n",
      "|    time_elapsed     | 97       |\n",
      "|    total_timesteps  | 87164    |\n",
      "| train/              |          |\n",
      "|    learning_rate    | 0.0001   |\n",
      "|    loss             | 0.0129   |\n",
      "|    n_updates        | 9290     |\n",
      "----------------------------------\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model.learn(total_timesteps=1e5, log_interval=500, progress_bar=True)\n",
    "model.save(\"logs/6_a/sb3/dqn_cartpole\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "kbUO3SvslNvV"
   },
   "source": [
    "#### Record Video for sb3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 392
    },
    "id": "Fk8sHqL7lNvV",
    "outputId": "28142e47-dcd3-4d84-c315-2fab871dd008"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saving video to /home/nsanghi/sandbox/apress/drl-2ed/chapter6/logs/6_a/sb3/videos/DQNAgent-CartPole-v1-step-0-to-step-500.mp4\n",
      "Moviepy - Building video /home/nsanghi/sandbox/apress/drl-2ed/chapter6/logs/6_a/sb3/videos/DQNAgent-CartPole-v1-step-0-to-step-500.mp4.\n",
      "Moviepy - Writing video /home/nsanghi/sandbox/apress/drl-2ed/chapter6/logs/6_a/sb3/videos/DQNAgent-CartPole-v1-step-0-to-step-500.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                                                        \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready /home/nsanghi/sandbox/apress/drl-2ed/chapter6/logs/6_a/sb3/videos/DQNAgent-CartPole-v1-step-0-to-step-500.mp4\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "        <video width=400 controls>\n",
       "              <source src=\"data:video/mp4;base64,AAAAIGZ0eXBpc29tAAACAGlzb21pc28yYXZjMW1wNDEAAAAIZnJlZQAAh7dtZGF0AAACrwYF//+r3EXpvebZSLeWLNgg2SPu73gyNjQgLSBjb3JlIDE1OSByMjk5MSAxNzcxYjU1IC0gSC4yNjQvTVBFRy00IEFWQyBjb2RlYyAtIENvcHlsZWZ0IDIwMDMtMjAxOSAtIGh0dHA6Ly93d3cudmlkZW9sYW4ub3JnL3gyNjQuaHRtbCAtIG9wdGlvbnM6IGNhYmFjPTEgcmVmPTMgZGVibG9jaz0xOjA6MCBhbmFseXNlPTB4MzoweDExMyBtZT1oZXggc3VibWU9NyBwc3k9MSBwc3lfcmQ9MS4wMDowLjAwIG1peGVkX3JlZj0xIG1lX3JhbmdlPTE2IGNocm9tYV9tZT0xIHRyZWxsaXM9MSA4eDhkY3Q9MSBjcW09MCBkZWFkem9uZT0yMSwxMSBmYXN0X3Bza2lwPTEgY2hyb21hX3FwX29mZnNldD0tMiB0aHJlYWRzPTEyIGxvb2thaGVhZF90aHJlYWRzPTIgc2xpY2VkX3RocmVhZHM9MCBucj0wIGRlY2ltYXRlPTEgaW50ZXJsYWNlZD0wIGJsdXJheV9jb21wYXQ9MCBjb25zdHJhaW5lZF9pbnRyYT0wIGJmcmFtZXM9MyBiX3B5cmFtaWQ9MiBiX2FkYXB0PTEgYl9iaWFzPTAgZGlyZWN0PTEgd2VpZ2h0Yj0xIG9wZW5fZ29wPTAgd2VpZ2h0cD0yIGtleWludD0yNTAga2V5aW50X21pbj0yNSBzY2VuZWN1dD00MCBpbnRyYV9yZWZyZXNoPTAgcmNfbG9va2FoZWFkPTQwIHJjPWNyZiBtYnRyZWU9MSBjcmY9MjMuMCBxY29tcD0wLjYwIHFwbWluPTAgcXBtYXg9NjkgcXBzdGVwPTQgaXBfcmF0aW89MS40MCBhcT0xOjEuMDAAgAAAAipliIQAI//+9Sf4FNQS/Evha2Ht1LdJMNFwsS2z0AALhXQAAAMAAgFy6QY/S0qm9AAABDAA4AfQZQeYiYqxUCV4WgRDOAECi6iEGpaZQOM9vsYqWErgYHLYBiOy+D/uEIqOQcxvUYBc5XQYLIbF+rdss8KtQOoyCjGkSdaew67lJZ8RvU8I7zjJabgjdyvWZ5t5O8AHUYAAZzfj4XgMw/pR6CknXktnRzOKx822PYASYcu/HxEXdK2CADQlpi35ADmx3PkJfo9X7uOWKtRnMhj8jYdR/q/z6oW+KYAKJNDBYp5t9Ybs+71ZTkQByiYVZ3qKRTL9QA8fVbfRhYgZ+wtKk2xpZY71lzwkZrUBZhN5Y4tc0BEXmu/ITdXIWpDDttKVYP/sAwVqk1d86xflxSwtI96QA4/8DkPC7EKtjW4zCTyYdG7PdEa51+3u3aXEjuLQxBvF/VSqG8pUwpRa26iYCLbUAIGSx3CajiMujr0iCmIDTxnbh10Nb6moc5yqei+xw2N8ZbrK0aN71YeEBp6BMqmXYf2k5BweCg4cg7WarqdfDpaLbCGJCh3RQ5EUQJszVh3EvbkVBo6U49SsKhxU9fImr3XVU35b7Yy6+6QND9PhXRN07eozNj9gnaRVVRpOu8ubMSBm+V4XLSAvZXE9ZTzgAACfDrYFoBHyp/dlUVrF2gWhaQZvfSEifRlKv60LXw7rfRhVLzs53mRHGGCBMyKMthYihAAkIQAAALhBmiRsQn/98QAAAwKgRG0A+fUx928BPeXbOsnCeG5GMFGW3bXid/jdryLD1mOBdTcYohB4gWwLNaSlnILR+ZpRtb9AHmn+xiw6/pDc0LMR+RuvyAzdClAOT0+dvYbROcgP09AGe9AdfbBQ2u+nNAmjHg1ZtrJhO8udS7bbIyg4dMoUs7p6PdZc+vfyDCI5kVtm94fq+xsfkwzd53+6XzegVXb/3BY+V/KXlFbvrVz1VZ9B/g5x58IgAAAAPEGeQniEfwAAFr5Ls4+Ym2X4MgnICmeFzedk1ugtgckXyk8mjTB+7PShqr7IGpf4SljjQEFeYqejRjilQQAAADIBnmF0R/8AACPAmd3nn9PQeEwUtS5plFhnFbwLyQXwOIKktQ5NbrvapiTRUKyV1PpWwAAAAC8BnmNqR/8AACO/BCXs3JEVbumsgoED5WiSnf39w9F37bfXVXxIiLzfFeosEElpUQAAAGlBmmhJqEFomUwIR//94QAABBS/UAZINi/Tj1jGZZ706juWXWKfFFyKH0ipZHf7ZhFS9XUPbZIJLkwE5J0GCeyb/Hf/symy9inUg6p3XtF2XVBLhyHBH30lDeuHK/IJVzXHHIsuK8HVEYEAAABCQZ6GRREsI/8AABa8Q823FqwTAeq+6bgxUmXVCPs+xVJUTCKZuD1Wvh3Lcj3CQADybqCQ6z8oRESXM6CWCQZ0q0qBAAAAGwGepXRH/wAAAwC1i2843Yi2y9jQ4EBGy57UgQAAAEYBnqdqR/8AACOxzA1IUENjAIMcYOui4JqWJIHrBvVkRBc72chfWxaRYRYcdLBrqMcfhQAg9yOKv+Vlb9RrBNpyrT3go+zAAAAAckGaqkmoQWyZTBRMK//+OEAAAQ2U/tcA4zgVth0a/+HKgmfKS8kf3FqlZBbj9vNmHFWS8g5BKEg+aVb9v/UFOVfWbXfasodUr9mZqyKHN0BYH+lIq2kBNLG4+T/2ueg7UhzNTbD9P0ABP/TwOZoIyulsIAAAAC4BnslqR/8AACOxzAlvmCcVi/zuEsX9f4cevC8TRwfNWyAPPwMeB47Hl6keMtmBAAAAb0GazknhClJlMCE//fEAAAMCjUJgSOkEB7xqO9PrAhxzdDn8/mdh7KbIKTWOjdGxKFc5R83wEFfGXCSrzrPJX+rKfB6ChQQv6YovvgECVY9+TH4igK4tfPdsyU2baXztZ81TgAx/3+AxYWAnkyMjoAAAAC9BnuxFNEwj/wAAAwMjTHyYWr7pJABHLw1oYBHnoWyA7FFLdrtq8wwAudYgWWA0lQAAABsBnwt0R/8AAAT4W3nr6NhaLyVwTm/VtyXaZ4EAAAAYAZ8Nakf/AAADAEN+On2Ko7lOR7qsch+DAAAAo0GbEkmoQWiZTAhP//3xAAADAqCs1aUGvMXlfWCAEOQVAOzUGD76SEMjefHpQ+l+CfTXBUtNx3kb5HP2Qw228z/LcTLyQ1L4Dcn4o6zQ3MVfNZbXNIFA7/rMntm9QA4ME5nT9DXJH+jIUtGWj1eTq92RO9RXVBBLN9xyFNvwQ6mZ90jMAdbJW1AigO0XDboqlNNWjng0YsIt7TwOYlQy296FUhEAAABBQZ8wRREsI/8AABazK7UEwTHJSObaIY8uevC5+tbgLLOax4BwBO3JpBx1HH3owScQIl4IXuo1KFCRVClUVEgyWKgAAAAcAZ9PdEf/AAAjq/hbeBKd3EV7pCB4+5FTDqREkwAAAD0Bn1FqR/8AACOxzAsoYAEproW1mDyxzHz7gy4U9YyIMd2gwdO64Grl8Kg5ZE4Mt6VIGSviUR5XLT85BsBBAAAAVkGbVkmoQWyZTAj//IQAAAYeYVbEyMUCILymYs/CFfap7mx6yPSRD/71avMyEXyiAmJLknYEYmBOnbigHrysa758DxAjp6sgXaqZXBlTUSXxptRGyPqgAAAAJEGfdEUVLCP/AAAIbYT/Vz2tYLSA0PAV4NKqyjWxK0ckpA+TZgAAABEBn5N0R/8AAA1+FClQIYAfMQAAADABn5VqR/8AAA2COhMxVBO4mrEMMyAbohaSaHQZ73O1WiaCk0NhMui+TAOWLOuyFdsAAABwQZuXSahBbJlMCE///fEAAAMCnwMJkC9epuCJM/EAGs/EFzx2SebMCin/vh0/XcqE6sdp13ziXfUAKqRYiG+LjsCMq09xKZl4tUerNlBXNSOjW8Y6jQhI8490GpoAN1Bw2N5ELpeCCNCmzaRXePyFfQAAAFxBm7tJ4QpSZTAhH/3hAAADAZE9wAL92tSHArCyL67smMbFgNSkKfgdFPfexQyaEy6ZKvRAjW8FHmdPORMCu1NSuomhoywUNlpWScRpBwGLmugN88jTjut21JvdYQAAADdBn9lFNEwj/wAACCwMpMkz26erkORqAEj4gx3wd6u0ROjrOCBAoKSTiIp+7fToh1f/FG3hvr8GAAAAJAGf+HRH/wAAAwHmBSUG21pqrFCcO26klqvU03bFalaxRU/BgQAAABcBn/pqR/8AAAUfMQpl1j7mqBHsAtQzyQAAAIJBm/9JqEFomUwIV//+OEAAAQzxsVgCL634kC3RAuxkx3s7S/nYtkcB2niGGOQEowPU+fNA7xvh7EmY1nkktyLLZReThTxbFM4mhmmpbnR/NGs8nTTEw2No1w0nDKUmHDtSghMNKhJGLrsvguvSVY4DxEMBOXNJmPh7QUmfr4IAMgWBAAAAL0GeHUURLCP/AAAWb5gSImd/kpa4GayhkG2aQBQwAFh3SdSXqHfpeWGYMeLaKZyRAAAAJgGePHRH/wAAI6v4W3gSrLVks3Zcd8KWvMgU+Yh/ZCp6vpT/lNJMAAAANAGePmpH/wAAI64xL9I5jNA6/JgALFnKhJSXG+xEC8aWPoJYue88YgShqNp49BsNBmceJJgAAABIQZojSahBbJlMCEf//eEAAAMAB8BHpbE73wjEPu0NgGQBdg3TR85p2x67/2Cy2g/oVEeOF8uXhvbqo8pU7ZJ/H9i3lxaYzvWBAAAARkGeQUUVLCP/AAAIbXzNXPaN462nU1kKPh6xdLCmFJUXDU6lxABwJNHEc1L3VJmvuaFMbGvgY6TmOXdI9tkH22SW+ZFxHbgAAAAkAZ5gdEf/AAANfhSV9Vf9h35dy8Uqh1jglqADXyPtKB6jhHgxAAAAKQGeYmpH/wAAI65eM4Iy9H/aZSD3g6WuyhE6SyCsQ10n33UDZLQdDw2zAAAAY0GaZUmoQWyZTBRMK//+OEAAAGd/jbQDV7sWEYyd6pvtlj+0b7ZDRQfSqN2HaWTD6GeqWqNG/448eGlVGgozqhY6NhLF8HjdXEhwMA9I7MZKm1NzTA0WOafEqM4bid0t/SdAYQAAAC4BnoRqR/8AAA0v1lRrABdQB1AlKayS2PuvM31xR7DLdNooBhcGN4ouX4P839mBAAAAPkGaiUnhClJlMCE//fEAAAMA9/JYAY0EXSng42RBxF/IGBiBUYw7SA2EALj0e59HAvdNxyzcGipqCJ2kS9tNAAAAIEGep0U0TCP/AAAIJz8wkeGYVmn9oekkLHwQ1/Bt8VknAAAAJQGexnRH/wAABR/Qvisgym9HDTYTDOsb6wdnTakY2Xp0A8v524AAAAAOAZ7Iakf/AAADAAADAakAAACfQZrNSahBaJlMCE///fEAAAMCnulU2DcFbwbkmkEqQONH5xT1Nr/cJ61jW6QFGgqRVsQkMLhikQW8+V7ywXz0gt6dw8AQhnD+7ZMqcT8Ag4WbWsOgiLpwv800SUqGyFsneywqo6F+QCfVl9HyrfTu9/vpm8CY1vVPj6Vv6D5zumWC/0AcTLOKYlJhuxh3AWP+uwRasSyKN+1C1fLmglq5AAAAOUGe60URLCP/AAAWsyu1A5DKvSDa9C5AqcAA3WsaiZA9LV4S4XFFJFxZv1BuFy/socdcIOBUCB08GAAAACYBnwp0R/8AACPAuN/BXpA+fmCoi3XP3PWtv5XaM860T6IqKxZbMAAAAB0BnwxqR/8AACO/BCcSyWmauFZTHyo7fi+tjQSSYQAAADRBmxFJqEFsmUwIT//98QAAAwKf7QqEVTw9QGORNY6Jd6gxpEjg8rjay2pACgfksiGJ3LmfAAAATUGfL0UVLCP/AAAWtSs4tsa+AogRyrHHWQqDdKSQ5QlrQAOKfoZFm/uudjO7qNw4As5V6nNnJsLKTxIazkLQtHuH8HUYCUqeSvBXWrbhAAAANQGfTnRH/wAAI6v4WdKQNaNqH6jdu2ll9y6mFAUXmha10m9D9Wf+m78LpwP1ZEzw7lHt9/bMAAAAKgGfUGpH/wAABR5HUn3+0JsI91AaT2zsdDJxW3ifsMnASX4PXpFK2b6bZgAAAG1Bm1VJqEFsmUwIR//94QAAAwGT/l4QBeU4rgpThv1dgswd6O525fPAUjVq3DGGFLAAtmsakgDvIIl6rJ9IrwUvIff8Zmue2X76nmml67ZtAUqe7WiB8I59G2fkedMDzww8uF9f9E1TsgdkV0FtAAAAO0Gfc0UVLCP/AAAIaZEWF/cALdlA6vK9CPWSya43nWpSSIVeJ4JfRogG1BdwSPkUyBUDGDxZKldSttmAAAAALwGfknRH/wAABR4Vf7LYg3OG9K9coQn2LwgL6v+F/xNphll9Ox+kLAJxpp3mAq2zAAAAKgGflGpH/wAABOoR0YTQUbbkvtjLUBCKa6BjCMQ6neBHYE0+Mzemf1lJMQAAAG1Bm5dJqEFsmUwUTCf//fEAAAMA8rDhoAVtmXlKB36jj6eXpORnAPm5gvG/5Ge+EUGew89s8mq4x/JR53ti2x+N7OavmgPp9nT7jXL9uLFftc0YDpEnvi1m0xysR57CZlLxHkphCVRcKVr/fh7gAAAAMwGftmpH/wAABR5wavNjoxqVUOxV5l633gnJJZFuoAANUS88iZx8ekFTLb1TUhrraew2zQAAAFJBm7tJ4QpSZTAhP/3xAAADAqPJ9Zkbj7/gDETArxRCvUyG1r55JeBLIYivD+j2qAEsHsGsz7k7IydTjMsL/Y2d1x4k898CdnUzjy7MH5vgBF6BAAAAPUGf2UU0TCP/AAAWsyu1BboP+GeN8UK32pi0OynSRLdul+qI0mEULjeBzAr59QAX1UbG7quWdDzLqm6opUAAAAA+AZ/4dEf/AAAjwxdpDqAButLreOfEVPeJ9fj1BrYfISXLF9Wg+UCZ8/QPG90mBh/TiLPBw+d1pKIJtb5PiHkAAAAiAZ/6akf/AAAjscwJb60QG3Nfr0TNSkd38sEhMx6C5vwKVAAAAIZBm/9JqEFomUwIR//94QAAAwP1OIgeRIzzSBjPGnACBaRPGFnrkAmZCx4BON0oOiX9XVYFYNzkhOmj0RQu1N3YHSsrZ1Q304YxrlNkOIIhjGw29pw4/6JEJ2Lesd+zqGsiFGHCWvmLxWYOyHexEwHK+odg89ejH6heK3QBBsc2vXwEwNX8gQAAADNBnh1FESwj/wAAFiMshuQMQMcx1X7NijLMUl85HGumjp2cAmvzqLAoGqnukoB6EzQcduEAAAAqAZ48dEf/AAAiwLmNf6psQQft/1ObBv0hSYEbQ4SimsDDyGGIReZsK7ZgAAAAHwGePmpH/wAAIrIsiBv/zjSlTfbeJqay4UBDCXcj3gwAAABwQZojSahBbJlMCE///fEAAAMCje0LEZkv+12RRPkoYz4KYSremgW7qWUQAWlDwMdGQI/oEoHM4GaKPl3w+AJlzcTMtszGloHasuRpeC72h7l6/5HmZSvl3QJ7R30R48B34BPgzVasCfOQ2KEfb9GRwQAAACtBnkFFFSwj/wAAFiVXfuHGIrTYcbmJ9g3tVB3jd8WcYHchmh8rslL2FbZgAAAAKwGeYHRH/wAAIqw5YE4AMJvngifmjP/Es41DmLNDI5m3ydhVWdOIsMOC8GEAAAA6AZ5iakf/AAANNYrksfq80wlqr8nykVVF4qWfJ+onXQpkJ7wZbroIAbQFM4lPvEFJBdCAQHU6fMDwYAAAAExBmmdJqEFsmUwIT//98QAAAwKNBTUUSJAAh/K1Rsl8dgEMsBYkols56ArkFYkUogdIzfL5xD7NcJstItBoZmKwMf87zcBr40mnXYbRAAAAQUGehUUVLCP/AAAWLE3EGY7+7dNdxSoHpyAFikbqwTBNo5G1Q/zf3sw94Naw9DQjN/NxdOJI83wI70GhOt0FL3TBAAAAIgGepHRH/wAADS4S8yWPCYYxxt8sJIP4zxiqcpb5/4c+LKkAAAAsAZ6makf/AAAisir9lSngkXyinsAAtk/fofn7DbghPUCFBR5Ln0b9YDrPrekAAABPQZqrSahBbJlMCE///fEAAAMCjbgoWYa8IboFGFoAEZCln6s22lnYV1gGNo02vPolPT4Hnr4u0nFKi5HIIFcGgzaOfiBXc3llARNRBHhMkAAAACtBnslFFSwj/wAAFiKe3jZ36fAEd8S53yQ5yfeELMF34S96yugxg8CeHDxYAAAAIgGe6HRH/wAAIqv4W3gIl2iB4ed819h2bVAQ7mACtIL1O3sAAAAcAZ7qakf/AAAirjEv0jLTqWMY505VmpDeIBQTcAAAAF5Bmu9JqEFsmUwIR//94QAAAwP1TY4b9HxjlZ/XJLAuZrXMP4Aaw13tr0gBaMmO1/iS2JaGygdsWWP0Pw4bK/mZxLwMAdC1b58HcpKEo3iBOl2fawqNMPj5PxHzq5q2AAAANEGfDUUVLCP/AAAWIyu1BblSJAA4tpn7yny6PbgapK+YuORaDVoek3Wermq8Dmo0O8D7vFkAAAAdAZ8sdEf/AAAiq/hbeBKdaClv1Sh5OmykVF2eJT8AAAA0AZ8uakf/AAAiscwNNpqjQwSWii180MIU7KcasQNpEo7rfRPvqbuenDt9usXgcVcoiBGELQAAAFNBmzNJqEFsmUwIT//98QAAAwKNBR0/YAr1CYWqdSsZ6OLQpleozZG1vuSZmyonYbfNQGjGapNlppa8dSlLDb0weLu/NwxQd3jGW1JW+p3xSZ5PQAAAAC5Bn1FFFSwj/wAAFiUrND1WOwBXBu3suaXJgXvK1PRPVjk9N7Q31bKx6dnumzpgAAAAOQGfcHRH/wAAIqv4XthDHwAEtRtIh3nvKNYXcY4gMubHd8ZfLjWLFXkDbNbJ8H7ANg4BIW5jWSw29QAAABkBn3JqR/8AAAT5MA4blBri4+xtWbc6//ybAAAASEGbd0moQWyZTAhH//3hAAADA/U+plL6z6ek8+983bOEAEdsSTDnTShRCJVkvcucUjQfPpfC+nq7gKKEnvYPxnr3A9PY1W9ywAAAADNBn5VFFSwj/wAAFiKdyFkztTJC6tvi4UtF+6pheEsmk85LN/LmY5jDOK2XEVF1XtUdNwUAAAAeAZ+0dEf/AAAiwLjfwV6RZRH6ge8kQ7i+Q2ZbrxUEAAAAKAGftmpH/wAAIq4xL9I5BU5ly5lTF+szljEu8Q6wyN1LVKCiE/vdfn0AAAA+QZu7SahBbJlMCEf//eEAAAMD+7/qZDBun/DHWbXM4Hdw26QrouAlZxmH28IaPnIA9y/gQFCXyE1ouAc2quEAAABCQZ/ZRRUsI/8AABYlJuOZlZaFUWgPAhvFeK7741lHWZAak8npr7T9V+CdQAttWq2xsrZoZ+GDSBXH4NX4LbWih8WAAAAAIAGf+HRH/wAAIqwVDgm21Osou9EtJCYvCT4MLxC/NYJ9AAAAIQGf+mpH/wAAIb8bPJu//bppdmlo4Y7xn7scpy4g74ik2AAAAGRBm/9JqEFsmUwIT//98QAAAwJ69+aakchbqnUbRTnZrKilWN0NNdusX3gDb60T3G+PoSadAibgCQFdnyKAHY6sWlOWsy29gOuHtt1YzMh2Ptet2regEqisBEsjCRhYH9nhqCALAAAAOEGeHUUVLCP/AAAVkyyLxKqCiUIho1zfLGFjMNVBleIgAG5hzRLwxuemcfRhCPqdgbO0Vz90b0t7AAAAKgGePHRH/wAAIcM+lqTtYEAAWxl2KuqXLJFy4MHriqfmnJTJ3c3mQyaXiwAAAB4Bnj5qR/8AACGyLtmIWupNEfJoD6DfuJjQYsoE6nwAAACAQZojSahBbJlMCEf//eEAAAMD3z6r7fo9mkrD52Ib4AC6gujAbBGeVf2S+5A2bxBJkQjhmiUFiUNAqQ8avLFTRC9x/Gyc8Ga/CG3VqLfi5RnbLeRvw5Uk9thFsWOM8rY8ZIopvZyjBfNGqgjdpAXi+s6d9yyYVerADcpfYMaAraEAAABCQZ5BRRUsI/8AABWSnqi0SRREbpxzAXOeUEmUCECy6Mn8XBmbIWTjJHSwjsHBzYX7WzZ68uAmZzVjqBepJZ4cMSY4AAAAKAGeYHRH/wAAIcC4+nzivVTaAEl9pwW8PLPKKcYSMZ9qqUh8RLQct/0AAAAsAZ5iakf/AAAhrjEv0XlDs864AqA5k4MyJD+GomXaB+vcpfUFAgBCb1JmQykAAABtQZpnSahBbJlMCE///fEAAAMCeulU1tDjdHI7VwAVg3dnTtRldAlrY5Ee0Qf+Z5S5azDasz+Ezq3vCWifVw+DqH+CqjoH2c6UAGRuCjquecxuDZhVBudNPfj9SjOo7s/ru8WU28OS4JaqeaVo4QAAAC1BnoVFFSwj/wAAFZKe3jcd4oAW0ztY3KEs9Elx03+blOGCN784yTLKacFKuOEAAAAoAZ6kdEf/AAAhq/he2IAX1Gusb8BGIKoKa6w/VuXPHcIGystJkyjjgQAAAC8BnqZqR/8AACGuMS/R3bg4/Hm5QllQj6Xq21Yqp11fbQ+jDT4rqpWeUjldGityjQAAACxBmqtJqEFsmUwIT//98QAAAwJ67aHTchzCMO0HthyloWRTulCILvsibI9PQAAAACJBnslFFSwj/wAAFZKdyFkScu3KF+I2AwwCjmJpKIQjVKUYAAAAOgGe6HRH/wAAIcC438Hv8fmK4jV/RpJpth+nADcWWfnjDwijEQx/bPhNY8g9IABXkg4qRLv+JsCpHckAAAA6AZ7qakf/AAAhrjEv0cwYJ0+0vQAC6GnMvQ7i6jVkC6dw3oz5aSfl/JLQ+c1OvTZruO0KPCw7cQ8owAAAAIpBmu9JqEFsmUwIR//94QAAAwPlv+pkMG6gKKArE7wCsA51tY0hsXFMJGtn232kAwUvqU0qIcaUF5MDqwL1kYgGHndm236AhmSuObKTysVx5JIt6g/b6JS21Jxg8k200RdyDEstrS9ZuHP+NHBeD4lLoCrycU2t4wS2OI6wQ9lne8ayuoSlkdVAskAAAABAQZ8NRRUsI/8AABWT0WPtZjP7nJqaYgBsPHsny9aOpveJg/rrhcnzjo5nOPy9zWJW6vjlLLeMSn1pUnWmieDXkwAAACgBnyx0R/8AACHDF2Wb7o+jap0ZpNEshOMsT1MwPeduajTmMjQBEkEVAAAAKAGfLmpH/wAAIbHBDcdpnVODDMjQAkuz+6eyRPCHozuA5oJ+9j0ARUEAAABzQZsySahBbJlMCE///fEAAAMCalsKFmJr3/qJxPrdQBcLBNubPX2EHvkcpRJ/R5zbof6PiJ6r4tfjoMwAtVGI4N2ZHOz4cv1Z1ynyIlERh7/Y27Qkm6o2JemmG7drgbH6VXXwJJbXK18fPLEmXC/f39V6uAAAAC5Bn1BFFSwj/wAAFQKfCd9q0GIWMcil9UBoIGFKufd6TkIAWbXqzrl8WV2YNKUYAAAAJQGfcWpH/wAAIK4x4m4Sdpn8vj1OCcTPBXiBnkldHICYuMEEuOEAAAA3QZt2SahBbJlMCE///fEAAAMCabvcddCEzs4piVnpvTtP+QVhcYNRBS0Aerc/EZ+IF+T1hWrawAAAACtBn5RFFSwj/wAAFL+WztNF2K9j2zDlpsvTpAAANZF1KI50kkDu5BZKkc87AAAAJwGfs3RH/wAAIKnOxZOFdDbkitbjg2B48DX3QVVyTZSBeRSQWn1WpQAAACMBn7VqR/8AACCuMS/ReUOzzbZAZSoMgvGLRLdA+GE3qcvVgAAAAIdBm7pJqEFsmUwIR//94QAAAwPKSEqYeij/C7rBWPzViUKrh8fWUexrp1YDuislNBPZMLIFg6B+miydeqAgPGR36tUG/byq2lErz+O4Wv4BDzXKZPeHqYCImPeR7cRSWXUn6PdnUULGnV89jTWLgr7hnzAv9GK6EOoW64rbQULzismLgP6ZjXEAAAA/QZ/YRRUsI/8AABUB/ZQ74fVknm9J2WcAAmrWKMm+lnFO8J8giHgkeiKCnrU+k6FwvNdgfDl7H6xjpMm7kPKBAAAAKgGf93RH/wAAIKnPTrtvkF3C++LTB3oerz3y/XKP1Is6ZXUxiaNL+gPyPgAAACgBn/lqR/8AACCtRfPfcvbcy/me5hSeFCLocby9uthn8Apth9MWkXTBAAAATUGb/kmoQWyZTAhH//3hAAADA8+/6mcMG6f8Va3Qww2/BMpAFYMJDooOLQVox0Eld1/sfh6ogKbfKdM+5qI6cZMdNjW49467BLzhTmH/AAAAK0GeHEUVLCP/AAAVBRfRuupX5azUCaPadMNYNcWMDcTts5pXtYQCdMXg8oEAAAAnAZ47dEf/AAAgq+t5oDUBASwSp5Zx2DreGXcRO1YUeNzgm2FRhZI/AAAANgGePWpH/wAAH7jt/1T0np0Y85WVCmA0LapAVGmXSg37etYskCTLIruo0Xw+oZTyq9sG3FLd0wAAAGdBmiJJqEFsmUwIT//98QAAAwJaW5Q4GkoZUnOIlmF6vhsVPp4/a7NGG/y33QgKGs2cN4OJRIq//1MFDx7lbWlo1dBG8qX0c679WFn2PGzYg3hItjPaewtUy1N27xVXtgUNt8qxpPM4AAAAPUGeQEUVLCP/AAAUcp6otENU0PtfUK3YGbEANiDENwfLPWTCtN9ye+D1gGpj9pVxhuZ/pv7frno7agpObXsAAAAnAZ5/dEf/AAAftnNNvlEUYjN8ynbedv5IAAJkH6IbiH6XTSILNUqAAAAANQGeYWpH/wAAH7mmf1Iy9IDHP1svkLwxQAkprXEYsIrrC7Rp8tacUttSBUVQdFjcjAJvcXgfAAAAVEGaZkmoQWyZTAhP//3xAAADAl3RNcqZ8XiZuRLPM323+bdFvvK/34a99TAAF6He7OJysK/fuDmNE5bMtv0FPWtj0gmSobwB0ve+I2pFwPdrzS8iQAAAAC1BnoRFFSwj/wAAFHIujeyZGtvEGaMEQSYMrrd/62aIuIATUGn9kOlhkshfHukAAAAuAZ6jdEf/AAAfyCy7CE5vyDKrSgFWLVATEsx81SdX6TgAE6zzFNr8bJo/LVtu6QAAACsBnqVqR/8AAB+47Ta9CGDs822QGUnIMxgrmdor8ACyEzvEmMuk/C5lcruhAAAAeEGaqkmoQWyZTAhH//3hAAADA51CYrRALV4d6e/Bq7YuCor09/3TrF7ttHrJerWnR3cqgGewSIIsxrJxM3dqVvDMH1ZYzExzCGbDq73aqIO7ve93y5izMOR3KySy94YgrVTPcTLLP+3X12uUA78zjomKbjEr54m3OQAAADVBnshFFSwj/wAAE+H9v++1Y3eTuSeJM2j3aZCfqbSLEesumNEqM3FQrU3rjWuIU5OX21T3oAAAACQBnud0R/8AAB8YyxwjCR6eWrGwDVp4WxjRzfR6WZqAwSDJd0AAAAAhAZ7pakf/AAAfHj3hWm/sAwvvwJdYRjT5NsI0KdD/9LJTAAAAdUGa7UmoQWyZTAhH//3hAAADA56Db4t+3pbSSI+fv7eX9C7NS82eWrOF2lnniqAffMHGXWeYNbNz+g6KbubPCNiaIT7/pujQbEn/LXqpZia/IMbXi04g/8jyXjsWGtpt1Rx/zx9gi1oXCfY2bTqG92QxUea+kAAAADBBnwtFFSwj/wAAE+Iu8QtkorSu8GHhIs8q7Ypyok9y0UssA6LZDCuxv0p7Eb8QekAAAAAjAZ8sakf/AAAfCOzacN88MGJd8v3m62YYfCIHeJlyd1wjzR0AAAA/QZsxSahBbJlMCEf//eEAAAMDo7/qaCAbp/xp2qw9G7psIg8JOMfo//uPkx7AA3OIRK9OifOPAbu0zske8p+xAAAAQEGfT0UVLCP/AAAT5Tbtddkniiplj4PGAS2qkeYQlDuyziAG7pbbjWq5Y2dFJ9wm1M4afSZjweOCkG2N5pG29WEAAAAnAZ9udEf/AAAfGCz/LuEqab1nR/qRBiFeQCJRFeRgAAbL03+1EZ9wAAAAJAGfcGpH/wAAHljuHeCyqvOJXEm6/i9QEX66hp/XP9v/uJ0mYAAAAGBBm3RJqEFsmUwIT//98QAAAwI5vecddCEz81AF/3diZS5lv+shYnTq6WWhAS9tqJAMw56t+CZ/Tg/v1BeyiPhME0XG3o7RgBli91x8dFaEGG+I35Og91rs3R7zyrpNVIEAAAAnQZ+SRRUsI/8AABNV4Lvs4YvdMOOnces980/T9DIbqjRxhYZEVUJJAAAAJQGfs2pH/wAAHljs2nDfPDBiXfq3PfTXy2h8OJnlQY9mHLcRekAAAACFQZu4SahBbJlMCE///fEAAAMCPdE1l/yQj43y+p8s0DixBlsJCOPldtIbQbgk4kQV8Ksg/6qyHrLZuA/Or/zTxqO3CvYc5zYYLlPJjHYpIVBV7PfF9XsPHuwdpZ3pKUDKBegJqQJxEfsij+94iy7cMkTbX1hlWkd3jnVpadQ3PRD8FDmS2QAAAClBn9ZFFSwj/wAAE102lCPbg7vuHc6XK5cThJOKtpSGANrYuH0MW1opegAAADsBn/V0R/8AAB5oLKKkT5SlBUaeMgzOOiK3OUwpPwoBOkuwEM7cLVGXlGv6bHqCy+AOXXoS2PLTbZmf5wAAACMBn/dqR/8AAB5ci7ARb5ztnHCsNLXRAay7JG+OFMgnTzzMMQAAAIFBm/xJqEFsmUwIT//98QAAAwIpwCnIS3xSY0+vs4EPzxug0+YDFHcHw1qvwQRuGhqvCERc6fM1v4UCDpaZ4sqg/1/yvaDG6mwe6mkAKssEqFj/yziGlRTcotOye/zK4MkFssWgGY6TSQFmzhFGS5YcEzOAMsrDOh/6yBa4uHSlNUYAAABIQZ4aRRUsI/8AABLV7477OQJiqmda7maVktiVFBa+DM806oSGt6IzkjLV52Ioey3JZ7PFbXYmQdTtWpAPELJTvueuvY88vz2ZAAAAKQGeOXRH/wAAHbgtDOfqsZKY5zeOCgeYEHTxTN4aLinh3iLdaCLGokAgAAAANwGeO2pH/wAAHagF1XstDE+AalUvcTvMMaT92Z4/exeCghWzAAFv0zJdS1vT/o/i55/9pRYSvaEAAAB5QZogSahBbJlMCEf//eEAAAMDd7/qaPlNPG0MvTIdAK2yzHweFrGdGMyUz3xK7v3xK3DUKAxfrVytPyQ3DTCMiR1q0lFTELMHnO1HkjtgUw73kOmp56FssT+2V5V6/kkVb5f5z87rwQMtS+ZzR62FjfCuFGqkvcnk+wAAADhBnl5FFSwj/wAAEtel5u6/XZCKYlC7JQAfMLu70Q5LJi9I6BFB1CurgUSgAURRDRpt7Mivv95h8AAAADkBnn10R/8AAB24LP8vFFBR5dgS0b3e7WWzqTo+tyrZBG7bP/pMLmEksCVYvtI5Se1AB8IPNd9LjsAAAAArAZ5/akf/AAAc+AYboUBwZimaneL6xBYpWvvI8Gcw8gBfMe94koxqB61qCwAAAFtBmmNJqEFsmUwIT//98QAAAwIZv6aI9y095aNgDkXMYVIvlyeo1c4HVmyRtDQz/kGsey+Y7BPv+ZE91YHUbViGh2qDVHZIwLE5jpUo5etZg22+EN1T41ep+hSAAAAAMkGegUUVLCP/AAASXV9utGfRDoepLZYUs4K+XtZxOB/OCm941yohBcXVCKi46s//5qUdAAAALAGeompH/wAAHPgF9fDnSIOxzqupSYRtCiWmgyH8Ce9R0Qm26bZCuAQX7qv/AAAAgEGap0moQWyZTAhH//3hAAADA2O/6mk4VaVAz8APiHG3SP8Wm6l5bxr3M/y9we58MQ/RNESoMLdIYYqmpOHt2vUIE07Z7ca5mYWBp4/08TTQFicXtO3cFg+hNoiNf/uwLU64mjhRJL+QEJJHPZnC1mfGgo/ENABunhSwoBZcaFrpAAAAPEGexUUVLCP/AAASV9b4L8UiYGDWLBKh4UsvLIrObOJL9myYui/IzQct29UogwoZdb1s6uPjLTw3S0rM4QAAAEYBnuR0R/8AABz4jM71bB9Prg7YFVDy1/ZqewfVfyP8peohbeDFmfU1OaDWIocvQ9/CkWvr45++hPU0kM5VjwOwIwpg/u6BAAAAOAGe5mpH/wAAHF5Lh9VOJDRSxabxWMmFSbmmKgDJF7o42AvrrrurBlSfnCXDCpyYmTAT5o7tbO4PAAAAa0Ga6UmoQWyZTBRMI//94QAAAwNPv+rQT7UABMt/ktB5/AKwhDXP02cy29wIBGmEwz7KrlHyFtusQVsH78C8Wc86Txz2ukeJU2VmJQrKUfE8233gjdkWvbjYd6jehyQUcLBW4OJcY1c6ShTAAAAALQGfCGpH/wAAHEgFR0SygXaNIxPTzdlpx1lB5ER8iLxFevF8W8rHRmNUr0RgqAAAAHJBmwxJ4QpSZTAhH/3hAAADAzYp4SzuKfCWiGAeBg/CN5jKU3EjZNaYrpxAJSOnh6ncFu1tn30bMQet7lCVIGe8VAfD1l0o4Kkk1aW6uy41ETnSZNfnokj6n38gcB+uTi9RCssbO4yZ7dy2J/UeftSqb5EAAAAwQZ8qRTRMI/8AABFdJVWQ7TlN90X2VKOd3gGO4QyPVd2Zq8Hbo2EEE4SRMJLSZ198AAAANgGfS2pH/wAAG5vG63sxo+Ld7Gucc/O9rBxwE9zSVLwQfPcLzqXkDH1UGjkoF5WF7Gu50sHDwAAAAItBm09JqEFomUwIT//98QAAAwH7Qc2wcUqGgBf7YqMBXQL6v3+0HNPIXWkBhdS26Ydgj0hmkPBXxmH66dzrZN6ALJ31wi7aDCirGlamXE+weDyixWhjVTlBEJSWiehg1cpvvhoZzzlz7FC53kqCe9GK202+wqkzjAGGd9A9sZzuYIVeBEDFHYr/jECxAAAAN0GfbUURLCP/AAARVgDPirgTxvndu1W6N8W5bUwRpfPDr6vwAcnFX3QmjfOaIc/NrsyaQecj3oEAAAAmAZ+Oakf/AAAbn2EcC/Q1Lpvbm0pyTj8dJFKHLq4EW/P9hODbf/EAAABvQZuTSahBbJlMCP/8hAAADE7/cICdKrpA7V67CeG0eUqGKhDo8/BOcLoxLh5Vigp7AvlrzwmdSMW66bAq5zfg82Hj0+4P4zY0Wr8AcbmMvEi3i74HjVfPA4WfmTuuuA5/LbBNdFskMOHgYP5DIO+6AAAALkGfsUUVLCP/AAAQ1gl2LEPSLFdoTM0rJnSgi5E1muO4b9wOslP3K2Q44AGvGv4AAAA1AZ/QdEf/AAAbCPdMTolmJHnPy54AiUghOjT1IDJO/O9Duiius7FQLffsfNk622Iq/oOem2kAAAA3AZ/Sakf/AAAbB5eig4EBcBBPA0R1lkeXwuzOV8e9GXmOnQd9y7beVkdBOrfqfF2AuhS8ADSKQAAAAFVBm9RJqEFsmUwIR//94QAAAwMQCWFapX9SP27em7GOnWlUFxwvK+qi/iAFbcJOSaAYcX86Z4QKyzaqXwBW+gxZNedtpxVBdl/Z1KkdAOKl4OPIy3CwAAAAb0Gb90nhClJlMCE//fEAAAMB59/1mDSQj5BwwyvDFLU8roV3TpQLSzT0yMWYasIg4mrxlNTC8zdANREbr0Y0yqxJSxTL9saYPhBQW0OYht2dpV+5WrN74iKmEYG4smuHzUFQXt9iRRFm1oVnqp1HwQAAAC9BnhVFNEwj/wAAEF02hwXE4tJoHhnSf0hOiogiBDs0GsLsfXb4SvAjhuxmpzKh8AAAADQBnjZqR/8AABpfRxqNGyEU7OwFrybMjfELGKb7n2Xoy98YMZUfnJ/RTpJFTMmJYxYPApffAAAAZUGaOkmoQWiZTAj//IQAAAuvo3v2Fzs14AFgb5Sn7jYakyisY0pdWQXYsPGaWRcPI8kuhW8iJQfbdNumL4qtTVNEbnP/idu9HnHSEM4epP76xQF0UtFDTxTpe3Z7MgQt0A0Z10KnAAAALEGeWEURLH8AABlyUHOMTkQ6+kNTqXSdsdnocqPkqg2O7bCXy4xmONzShDZOAAAANAGeeWpH/wAAGcehEKWsR8GC3sOq5nliHjrzb529Uh2ZMksS7ur4XLd4XhQg6MLckBmD6YEAAAInZYiCAAv//vau/MsrRwuVLh1Ze7NR8uhJcv2IMH1oA/wDMfgAAAMABcTL6N/08qXu6AAAAwJcAHIDxDFDAETFWKgSvGXweEPACnZzReKl5QGy44Xr8Yg9iyJPCBd2V/cwMGLQtvqpBhe7982BVxBGjqHnbZomj7tvwgTYTOcfRCKszN95hMlrBoJ7x3UKkK2MS6kkDCpHvmqAMUUQbWyXK1tcWFsE5+tFuxiAJV43FI5HetajZmVp8St9ZEKt4OaVISJKpCzmxc8k7Ydb4qrgLre20CN+ytxvyQJ56mV3i4RmarysRvoZ/AURVNuuRwL+3PIVwWLW2+51lt0tWfBlCo1n2H3Dr6z0AvpARorbtlDp2SgcEHMJ4Z8GsL0qXlY3Mz4u0yh66k3DR/6sc3AqPUQRRwB3HMSdnMGXoOvS9eDMuQuYrPRVoajexcWEbJX/YGEii/TXgigh8INjDynwq3W2qbG7sdeBZu3fiB9CztLSmqdbEjWpqV8yaS4+80oCfW4Udo9BfWRj2sV2KtEzFJyGFq7XYFTXGN+6PgmgapPemd23Vvlj7xoa9woPq4x13ZhQWblEIRrOPsKOPtA9URuVxC/KRyqINsKZA64RnJq7ACqmO5DAFOzKE3eg78Bf+zqYDmcAlnrpeCBLs6nRxjpUs0ZcHvv/vybxFEB1EUGMh3X7biUC1v5T9S4bHSGeqtBMTFfc6CkpjqGCcrAAAAMAAAMABswAAABhQZokbEJ//fEAAAMA+D51+71z7+G2WvpptgADUi8N4ue2n2MleVIgrrQ+KFsSeLYpVn54/yhdaifSEnDlRLnm6igR6LKJRitUZXoiGUnVvvcFKyMorsVPby+Vh0ibqKh8kQAAAB1BnkJ4hH8AAAhsDJQKHr1u9DmLj71c0urhEprZgQAAAB0BnmF0R/8AAA2F7vHlfR0pJH6MSAx0UmjlCw/5AQAAAA4BnmNqR/8AAAMAAAMBqQAAAMZBmmhJqEFomUwIT//98QAAAwKe6VTW0tea4TtWCAgv09gKFBEEN0Rw3PpVqIcedMfGqSND0h8pc1qTk7QcsVEodiZuz23sP9MHHoFI5IVV6DdWB7sii/GI1pvNHKUTLAQ3UzRIbuXkYT8LDivNwoiHfVTYrR5L92gllOJIFiEvR/kBVTsisVixY3qrPGkU9GxvO0f4121g9RVr6M92x3RF1Zr4pWhjLYQ4fHRVqNojDu6MAOTzDmS7AHX/QDzcQQpvUL3nyiEAAAA5QZ6GRREsI/8AABazK7UFEcO0B6ptKr4mzfXPmTdA78LZDJVOJEb14/6q1f8MbmI5ZzR/EETx/pJgAAAALgGepXRH/wAAI8C4HtwRzbX9Eo7xEhH3qHB1OrxTiZhuXKKkh9sb38ScXyUc7bMAAAA2AZ6nakf/AAAjvwQnEs7n325ab0ET9Il5WAEjN6upjInUWqb6PGSJnn0ibLCQz4oAiKN3k+5UAAAAcEGarEmoQWyZTAhP//3xAAADAp/tClcx/F4+sqpLI26SgAMZZ7AUKCID2/BlDoAbB+AXvZUNIpegNjRJ7bPYVockimMeYDuAYtMwRlY4euAgeYVDxnJeFZMETjwkLtSlCE/sNU562w46+5Y9puJwPNEAAAAqQZ7KRRUsI/8AABa1KygAXcc2A/u14dtt/kby1ly9tKwluO6Io7bmaF+3AAAANwGe6XRH/wAAI8MXaTCAAF1AIU0JPwWAXqVJPWXc7Xx1FN2KiJeWDBPpzDlvD4QDF/09NE2P3AkAAAAdAZ7rakf/AAANhWJl7BOkJEng6xCkALnE4w+7WLEAAACSQZrwSahBbJlMCE///fEAAAMCnvbeTagc1ST3R1aPnaRgeF32MILHrtl98Em6FLxpL2rXpvQKnH/uFuwM20W0iibWjzEzxUrz9qEDB488r2s8B6ApdEBGY4rL39ulZeSbMdG/AQH8uTSfrxenH+3MfGupfMeltQCCu8VTHors9UE+6+bBdBdDPgGyQPxL128I1XAAAAA6QZ8ORRUsI/8AABa+o532ovRnKiu4ABIPnZLDXQYzqsjx/r4VDVgqjXV6ezx9gkoNQuJK8ZKxko5JgAAAAC0Bny10R/8AACOr+Feuo1rrkqeLrZptLpySaAWEhQA95Z8MMAEbb2PqftvFLZkAAAAqAZ8vakf/AAAjscwJwTbF46SH0b4xalqUMksyOh1QHCmZXKtav1pn4pyQAAAArUGbNEmoQWyZTAhP//3xAAADAqC0PRG6gFi52ZBW31u7p0RmzJFdGbG7xYWtqVLeBP8JkPZh6FsIqubkG6LnZiS9oUi33KUwJvW/Rhtc8oGv/pybSp5jHV9G1fnKMHc+BU8sbXWnsmGpMAs+UkrPxAgfRgu9XE45IZQxFom3/kXBu3UwoHGqBHNUE19AtuESmgpAZP9Z2B8Nbc04UPBU7URvqN30hNLPBgk6o9ywAAAAO0GfUkUVLCP/AAAWu4p+XF4P4HgUHLJ19qV9lyyqgYxKWnR7Qond2A57fZbWjvXJffrbApmZqOeZiW2ZAAAAMQGfcXRH/wAAI8MXXzbGw4p4xuYqnPf0EhWQ+aVwNr7JhkbtwjigZEI9ZZ7kle208k0AAAA5AZ9zakf/AAAjsi3a1t/DkQ6b83Y9QQYNs0Y7II2ILsxkwQNLYH3McQJmXPNU4ALabMWBbwRCBiQFAAAAZEGbeEmoQWyZTAhP//3xAAADAp/y5ahmNnigFJ0FLeWJEkV/KG64qJghSzl6i3JmqQAlZVQOgZcA7cxhgVKUMzaP+IHzN4u4cFsJPlcEVraIUe8UlK/a1phrinF/0PVsDbrlxtsAAABEQZ+WRRUsI/8AABa8Q8xz+GRrbsyr19zi5wNQr+83gQqKRyrRDrESiehTpaWPJB1FDo+qHBgOmAALdMUQA7w8jAfAbbgAAAAeAZ+1dEf/AAANK0ZNuBHC1Tc8Ii1yXF5zmgMHfn4PAAAANAGft2pH/wAAI64x4nsJhCqkACIrTWF5N0fwQ56DesTwToh8puQAnOOvKnxZr8ApYotrbZgAAADTQZu8SahBbJlMCE///fEAAAMCnvfeTaacZCUIAcnKBp79Iu5corZBz8Cpizapv/h3ppUbFCFJgs35Fq2PDN0Rj4/AWeGENZojW/v8YRK4X87DguKs1DxZ8736HzkpO7DbHCcrOza1+gjv/o3g98fIO2sjC4AJsOMt6YLqCzsJuxh5pVwqwtrpYPWXDLld8qtnT2yi0lcR+bjkBHvNWyHvUu+uJtPdQKeVSaVPvAYjhXcT60ZUOFtkEzISbOz6jDnh2ZG98yOdZvHThK/X+c4GvtzOCAAAADhBn9pFFSwj/wAAFrMrtQK1/HmcXjhxdKx3bXU6ufjjrlVt8vdhSFCFxU2BbmW1EYUQZnPdzPPgwQAAADABn/l0R/8AACOr+Ft0oGaMdPePFthFN52EMw0u9DQrJFgD0KwOB6MtX/fQWICZJJgAAAAxAZ/7akf/AAAjscwB+C78UlrVOeR3L8WKj5MZUSK1P57MemYIWrX4rykEPtrumTs2zQAAAMBBm+BJqEFsmUwIT//98QAAAwKfBsm+A/OETkcr/ZzpTH+BghmGZE89OAxeSQh2ryWd6BOCJKpJp5Avs+52JR0NkzcJ2wQDf7e+QeYcjb5bXLH51Qye8Y/5qE1fsFzxwVu2raUXZzFCeBuX10hvs3O6Zvbbns+vlQyGeir41pytnrWBo8RuOL3SCoyW1dfwiN6edyCz9e6j7tpY9NX8OueOLyEfD25W/zEbeo99ll6LruNDmSq/wy+YeTOdbSRM1k0AAAAzQZ4eRRUsI/8AABa7lFSxg3bnTV4odwh8CjnFYkjRIc/K6y6OfCEkxlTAOha8eajrC+2AAAAAKQGePXRH/wAAI8MXaILrGjPyOxSpAd/85vlEupQBkH5SZ2nrarYbIYCBAAAAKQGeP2pH/wAAI7HMLiiurKrQbeGctGYvmKrw5HgPACD3ruRqEZRb6WKgAAAASUGaJEmoQWyZTAhH//3hAAAEFNVT/f1k9IkLQPzdP9T8qfuwPTwmJ+1rshZsIpFod9k6q9Lbem2fRcFmEcCmGR4VYFBaaOkjcBkAAAAnQZ5CRRUsI/8AABa8Q81GI6dSk+4Hd015hK4X3w3iTb/E/AMyBWQnAAAAHAGeYXRH/wAABR/L7RU0qnqfliea4667xseSG2YAAAAbAZ5jakf/AAAjvwQrw0DZnGqdLDEEYrO5WQmAAAAAeEGaaEmoQWyZTAhX//44QAABDaKQEWfnU8gGrtfPdPEVNSTaxTdsjhfk+xX6SgROe01cOcKCy5UQsi92c8zZ6F4QMYICUHgseCZ+pDCBa7lAiVW9BpMFS0yCudrzGBX6tWvx/MhHIljkPl075+J3/rgR99a9S3DPgQAAAEFBnoZFFSwj/wAAFrUrM60xyEmXUOHqC/N2NWfwn+BwRC+s9eSJGVzd0iG+QAnDpgpTA8MdLXRUeTiEqtc332hswAAAADgBnqV0R/8AACPDF19zGHnmH53NsTTmwW776mKOk4LsGMgmv2j1dqnY80FdA1WbOXXhEQEFZ+olQQAAACEBnqdqR/8AAA00nVr7ezeZs9j11oFBh2l03KG/vNzbOQEAAABNQZqsSahBbJlMCE///fEAAAMA8pb1GbsknRsREAdx78y2gD5sMGT+WR2BYy81S4WoG5Vs8FwmtEoshMiVT2qU7dfD8LUCKN0trV62ncEAAAAsQZ7KRRUsI/8AABazK7UFt8/cYXpN9Fpz6JvSzY7JtIP12EuNuFpIj0Zy/BkAAAAzAZ7pdEf/AAAjq/hbdMLgKBVQAFfci9hNYlU+5WlW5hEY6sgi8/8msfcOtWBEN3l73o2ZAAAAMAGe62pH/wAAI7HMCVcXoG4AFz1cp0gJBZQ7rwkynf2Xem47S3sjMhmwQ3MKPOY7bwAAAIFBmvBJqEFsmUwIV//+OEAAAQzxrJhjAGsa27httneqzeN1t0qBVvC6E04/VuWqkszONCnFi2Y7NO/sqsvCt7rTf+lYPJhYPoz5uMcJqxhk61rI38V409DZFvt448pIns9kVmiTwaEFBZFWr+VpZJ1ow4IStX0g99n7TdOuyAema0QAAAA5QZ8ORRUsI/8AABa7lDVdlEtbhKYEhAAD26skkCLVqXqbgNbS49eOQK6W+8f9oTm3I5XS+IMOiRyQAAAAKgGfLXRH/wAAI6v4WdJ1ATvIEaHiofJMAdC7clnt6zwI7zQAiUohEH1tuQAAADcBny9qR/8AACOuMS/Rk6gAWLPOobWk8tOTsDIeVi8KXVjqAEzXsOyLJmd5o90ATwNEIYeog3ICAAAARUGbNEmoQWyZTAhP//3xAAADAp/t+GXoVi1ASPD05kmtPYAa8iAeMWUcpL/x2GTchVBz/cm4B0NGi4wdDH6k9G7j2rumIAAAADBBn1JFFSwj/wAAFrxDzc/NBvOhxf8mBqbHujSCZZwCFUe1QArBhPA+iFdyOQFrEk0AAAAYAZ9xdEf/AAANd1AjLbAUyFMDCOcJkIpVAAAALQGfc2pH/wAAI78EJZrb2ebtZ8+yzF34npJhqe7ZUNB6oobsihgRIB+qgVxbMQAAAERBm3hJqEFsmUwIT//98QAAAwKfyGkBbjnZ9ZjtwIwHLmQH5+ArPRupwXGy8hiZcgHBZ58a9JOddSsFatu/XPzTyAryuAAAACVBn5ZFFSwj/wAAFrxDzbcVdEPs36fbRmT5bLqCpwugF/Rg+38GAAAAHwGftXRH/wAABRxXHbFlYeB8uoknk2A4pBlanLYjJMEAAAAWAZ+3akf/AAAjscwJb6lvshVShawS8AAAAE5Bm7xJqEFsmUwIR//94QAABBNdwJvwWPEtoIMkANpvNezBoPq5Y7NqPxOa5dUyq4LhBoT9ebOEqGDGQ169kt8CJeWIG3er4WkivKn5mWAAAAAuQZ/aRRUsI/8AABazK7UFsTslKG6l4DXXneSwBpnxGOS9JcnAMgYF5Ey+aTq7ZwAAACwBn/l0R/8AACOr+Ft4EJRzYzJAAuoA9An4kw/vnUyByvme1JUtAJH0xmxOSAAAADYBn/tqR/8AACOxzA1CS3IgBKn20c0sjGnTZ3SNEmzVW19SHWNp9nGKroLZY7ERbvfKqOxy/g0AAABCQZvgSahBbJlMCE///fEAAAMA+CD/NM1bojuhWMYsiicBUpnzbygP5YBeydnxM2pVdQDmomlNhivm+dlrQE13URTxAAAALEGeHkUVLCP/AAAWs0e3DSK/nTXwP5cy/mWFBISj++yRRkSLIXLCkPXjCkmAAAAAIAGePXRH/wAAI8MXaFURGPNd4JyCs5gCGKiawlNT2TSTAAAAJwGeP2pH/wAAI7HMA5FFtEEzK3kGeKGIV2raUy6I1orEN452sgHtmAAAADtBmiRJqEFsmUwIT//98QAAAwKe9+Jc+XYzoNtXpBCwlTysFM51e9YHFHvebi/fwSMOL9dGVIkck/DXYQAAADhBnkJFFSwj/wAAFsCbP3Oq3JhJ3810+7IkYJAFXiJYiUgeIr8CZBf4QZEoM9rnnQAcE6dVpQbUkwAAACYBnmF0R/8AACPDF2hNl7jdFH4qMslAaEfiUn5MCjcQuUCh9rTW3AAAABgBnmNqR/8AACO/BCcSyWmafvKkf0QSGzAAAABVQZpoSahBbJlMCE///fEAAAMCo+wzBHix/apC+kiTUiX0oCbYNDbS3vOR1ZvVA3bkxrWutEdVIYwIm4GKHmMJpVK77X96/yTJR094pnTP5BfjSRyiIQAAADtBnoZFFSwj/wAAFrQ9z8hTx6n8GZKMn89wycMuvaAG5YbZh/PRQbGVc6aJhotu9i2EUzA58KRIF+jkgAAAACQBnqV0R/8AACPDF2ipqOjDHfivK5dQEMrcG0rTQcOxmHc+24EAAABBAZ6nakf/AAAjscwJiZW/0POGSkkwAqvsUIeJv9HbBTj2naamrZboYldBqd8rSBFyyV97eF2XVT13Q6NAvJdMHbgAAABTQZqsSahBbJlMCE///fEAAAMA8qD/NW47/2+TqDi3SjcHPMOACH1F2y1mHUfib6hh1yE/ROdW3w7OxtAA5a5HmnKT9VncoSMFqm2LqigLD1CA5uEAAAAqQZ7KRRUsI/8AAAgsCADiAGnXuMyg1dVE/hAZI0LhRwEOkLi0w72KxWp9AAAAJwGe6XRH/wAAAwHliHANtDkKknZAJ9MTlliZ85BLtQOfcvrGvfXbMQAAAB8BnutqR/8AAAMB2s1THh+VszJ21Mj+GFHpDMk72FxZAAAATUGa8EmoQWyZTAhP//3xAAADAozpWPjM8DQBcNa7/yKIZ8XHRWqRTDQyrkrnUWh93KkucwPq0ezkMqkZISSVzQXp1/c2w5HDhFuRvf+9AAAAMkGfDkUVLCP/AAAWK5SR6xWUrmAKABRq9HYVUXpXT7lvPIyMevynGP6zxqLWcZohzNvQAAAAMQGfLXRH/wAAIsM6Z1+aFxqgBYs5/Hl67mk5hWezduX7hO9zbHZ7hCcRACKz2nVj8oEAAAAzAZ8vakf/AAAirjL6/EyxeaoALbq7/McZt+Idi1oc30zuVo7QOyIz+Zig7SfFZBZmF/5gAAAAfUGbNEmoQWyZTAhP//3xAAADAoz33k2jWolS09skfVdbUQAP5s3i0NneS/Hev943JCfAoyIEPkvuKhrbLdCqzDnMe8WZ2orhT/9mcwG73mPQrxhC2PDztGtvMIHJb4ZohY41M5brYQ3xAMsElbK50wZo2Tpsm4JJQbjQ6kBYAAAANkGfUkUVLCP/AAAWIywDnj3tGzftjEfohYJD1MK7BaI8+NpkzPpnUACM6SfBqcVoo93GATRUYQAAACgBn3F0R/8AACKsOWCuAAJFsvYmNZkI5XXG4Bt4/7HC5DUseBBSk2HJAAAAKAGfc2pH/wAAIrHMCYjsbAaQFi+DFnr8oim2MYcIYYn5/W9cIhBIWoMAAABfQZt4SahBbJlMCE///fEAAAMA8/mfQbmSRX6z0PzEWXhFhAvRAe+RFRqvf/41oqOI9glEAatOkjECLBg2jjkmTYWYXLBxEgB6MNGhBU9c1Po7rQxBVDDwTsR0NXKSwRgAAAAyQZ+WRRUsI/8AAAfwCJ3m6fXb7m8ajPuHgsv2c6F5BzD+hC5p0bEyKF/mhGwCF7jDonwAAAAsAZ+1dEf/AAANL0pioZSs1gLRWceleM6frAH6EdeDXF0OxoUO/I+fQhRhp8EAAAAqAZ+3akf/AAANL9T/hu81j3+Sx4ilAWvUHZ0KN3Brv7f08Tmhpjn9EsqAAAAAUkGbvEmoQWyZTAhP//3xAAADAozpVNbQkYAArTj2hmWUCNjq20JBh7XxmbDUmBNdbMdKiQb/GOdvDLVEahHOFI/XyKniwGqAffoMZt9yQkvlJUAAAAAxQZ/aRRUsI/8AABYint43G0cr0+ZV2b1q3mbKrNEACGgUePIMr26SxggK+m3UFLregQAAACwBn/l0R/8AACKr+Ft4Ep1oI4iuvyvYIwF3QPDANH97vwAJhyTdQHJ+QXP4QAAAACYBn/tqR/8AACKuMS/ReUUhfCAFtlLH+39U+V7NugeZtTXtuyEC7wAAAGZBm+BJqEFsmUwIT//98QAAAwKN7UQVzH82pQupz+Ji/K4ET1eJVnEqi2eh26AduxUo9Kos5xIBMAW1nzslFckmJGfxC/1vnn2V5SOGR++YJEaS8rpI8tbcFmvHV++3I/WLFtsQPYEAAAA8QZ4eRRUsI/8AABYjK7UF5Cv/P9kpHFgADjBw5dDRszjbwI/ZEdAUJcexdOZuo7aEKjpw4zq3jkNQ0eLAAAAAJgGePXRH/wAAIsC438DLo90JgcNyJj49WfnnJhs9Njg4LsJxYRCxAAAALwGeP2pH/wAAIr8EJ1ZDvUkASX8dtVPheKPqFAAJ1nN0y9K4r5LLhoXMCiyprNwQAAAAW0GaJEmoQWyZTAhH//3hAAADA/VhCjfrMft8leHZueoAresazQtjFSq6AFj2M8oj3iDxgtsKIKzxTyAvRsbLfUy1u1oVq0gBBUInHTg+qnbi8rUwBusxoMIEmb0AAAAkQZ5CRRUsI/8AABYsQ80cmGChmFoBFo+VBNwJIGXQG+9pXnTBAAAAMAGeYXRH/wAADOe1qh8c4lsCCCboouG0Y4WPapCywMABvlRH9RMP2sV/vhz/hJGTYAAAAB0BnmNqR/8AACKxzAlvqW+lCF+f9xs7v8kojzqxCwAAAJBBmmhJqEFsmUwIT//98QAAAwKRurgRvk8zzNqhf96eMZtldgOKfQHZCT2dPFdL4qRQYhI5p+nboCPUD+S9h+MuTwhGGAjGUQ3oRwLxVkkKzMI0BcRbpk4/Uog8222/mE7umcC9cdA1gB+sHpU14gxGxXH7VAI8kiUUzVCvH+1ltMlT2pbh1+DeSRFrvlbE9iEAAAA/QZ6GRRUsI/8AABYjK1TvfEFQAjtoJ3La/VFLROGGRgiH3jED1iJ/FZilO7Gk/x+q9au/Kal45If250PVfxcEAAAAIgGepXRH/wAAIqnPVM7UwmoZkK5RbXApnQGkXpYor3gZDb0AAAAiAZ6nakf/AAAivwQnEsrEx9mc+1ingQXJJ9B8A1N5HwvPBAAAAEJBmqxJqEFsmUwIT//98QAAAwKRyfWWGQj47EQVxFcnXD/9TxkMEHOaKGurUmW2RBQB96e4lQyylDfR46vqlPwOneEAAAAoQZ7KRRUsI/8AABYlJf1Mqw5BWOioDrIqBi964A/C5oosn0zrAe7t6QAAABkBnul0R/8AACKr+Ft4Ep1oI4gRnpPkd0UlAAAAJAGe62pH/wAAIa4zBRoCy9169s9jLCT7/A9gAhkh/IrzSI87ewAAAHFBmvBJqEFsmUwIR//94QAAAwPggwUbzadb20BWcUwzfAAmV9q0/UzZ+m5W0AAwcxIc53GzFCbvI1NEHAWSePDvEu4m73fbnlaJGkMuVghlKv6OTrryEQ0xnpXWkd7r40+tUBUcVV3cIUx6bYuiNlZK4AAAAClBnw5FFSwj/wAAFZKfCc7sxD82qWna7vWyefnLdMr6P/afGAWxMRG58AAAABUBny10R/8AACGsOQWuTx8/FWiNG9EAAAAmAZ8vakf/AAAhrjHibhJ2mfy+PU4JwrAW2Nldtfzjk1PVaa5AMNoAAABcQZs0SahBbJlMCE///fEAAAMCeulU2DcCoGhpbXjyCrt/j4DZk0EU7jEy7umCoMZrTrWegf93/oJgSlUkGpLngrguUlLV5dnJxvR3bY778qyT3FecVE43Zw9O7dAAAAA3QZ9SRRUsI/8AABWSnt43G0cL+XRBAPtIyT7ftS/Fs2UgkmS6Hq6MAC70kyzhV+/BHcpGP/Ot2wAAADMBn3F0R/8AACHDF2n1ieiG85hopBO75XLr/AQ22EZn8DS9hs+yQMboB1aAn0O5HYaoKkEAAAAxAZ9zakf/AAAhrjEvyvsLHRHYfiFYtpzldnf4hS+UZXKVY732hbTKLwyGp/0jVRSFSQAAAEVBm3hJqEFsmUwIT//98QAAAwJ77UQvgWqBU9b9Z+hUypkJEAig9MrNquRH91cpemK0siHkpZLOmrCg5Q9tXZhADbWyJxEAAAAsQZ+WRRUsI/8AABWTK7UFuRxH6AOqOIyV9mVutOG2p3ivGwl6ryLGCKD5VIAAAAAiAZ+1dEf/AAAhwLjfwV6RZQqokYkvMfDVm48yDGN1E1RCpQAAAC0Bn7dqR/8AACG/BCdgZCoi8Lt+O/kSxf8VtTr41JJ5g6xaxNx+T90AcBLydsAAAACDQZu8SahBbJlMCE///fEAAAMCeu3rUKtIliQGGkAzCdQ+uOnGuMTP4KY94dv9s2/FM43xnDwwEHF9cKslSt90e6s5gHb9rOnwUQBVG5VsP9jTTCPZG22DO2ljOUn/eWUsJ0fxAMnjgpx1vcR8bMYg7+pHOvUe7Noi2GyU40j3AbZyzSAAAAArQZ/aRRUsI/8AABWSnq+UrvfB104+eQW+/j6RpKGiiy8SDHbqhFN0yxxUgQAAACYBn/l0R/8AACHAuN/BXrcoASynI+UG7hbBAjmk4MpFy/ZHgUjHxwAAACwBn/tqR/8AACGuMG+/Bm3gcZjjMZLhVa676mLX1h41WhXiAkgkTlk4P1cioQAAAGhBm+BJqEFsmUwIR//94QAAAwPlv+pmWG6XflXS11OJBQ6INe8gG4oFItStL+ZbRWT1461dcMvKq28KAaK5WUz5pAOwzHeXJPFEuY4u5i9EXHWUkE4Vm8WDL8fZ70eEgXIYCYZsCRzQgQAAACpBnh5FFSwj/wAAFZUl/UzK1g9vkpB9YCCpaMM6nwQ8IfCiYVEab5SRlGAAAAAlAZ49dEf/AAAhrBUOC/NHg6B9HTKeHyQJJ7EYmqXAlQ8yMHCKgQAAACcBnj9qR/8AACCuMwUaC7qyOHXmRhOA3FdnODKRLRG4Z8qYtmvPFyQAAABQQZokSahBbJlMCE///fEAAAMCabvcddDjdq4aTX84AM9BLK8BEJzC7X7zNcaIDPRIllrxcduikd9Hqs1fkoWJ59C4b+4LvCPv7Vy0cCgAfIEAAAAzQZ5CRRUsI/8AABUCnqi0Q1Tn35wusidP2gAha7o8hablnsYd7GhPgNk5kw0K0BZtOhiLAAAAKQGeYXRH/wAAIMC4+k39b6/VldfZLVulLUi73ogwEI8MX3gBjpX5PYnbAAAAJAGeY2pH/wAAIK4xL9Iy9IDHP1laqwYdB0klC6+dUymIOO5f7gAAAFtBmmhJqEFsmUwIT//98QAAAwJpvQZFYfjdKOzX6oAAWJqrY0RMmICjNq/MCjECXXrbd5VovsTSbd9S74fpuQAUtP1IT6WWvkaLcy3trEa0YQrd88ACvysOLRSJAAAAR0GehkUVLCP/AAAVAp6otDztVEhnAvUKzMMofPxS+eOyEFNl4V6H0x0UUHcFQCthoNSJRtQ68YiB2yAEyhbyS9lRMGMwRsfAAAAAIQGepXRH/wAAIMC438FekWUR+oHQMxcJJUKsrtbypnwOmQAAACYBnqdqR/8AACCuMS/Re51wytEJMuqpBZWcoGuywTLUgGrIAaz5ZgAAAGVBmqxJqEFsmUwIR//94QAAAwPPv+pmWG6gCV0xkwHoANRnsoSjlTbPUsDC1UtFL1rJUsKr4La3ny+2KQem+9UwrgGZyalCMIAnXNEXkiOEQSYJnavtw2JJLd6w12GzuPN1JgyLgQAAACZBnspFFSwj/wAAFQKfBMDKHUSMz46k7YCHmahsTvTSMHCdqGZI+QAAAB8Bnul0R/8AACDAuN/BXpFlEfqB0DMW5+mVCkyss+PLAAAAMAGe62pH/wAAIL2VrbtPjD/m0w8qqy+hufn1hfTAEB+OBNHogta3T2fzvEkYE06zYQAAAFZBmvBJqEFsmUwIT//98QAAAwJZvecddC+GuDOke7Tugnvfg9vBIAMDsKOBib2amuS7WbzyctAdIC+FwvkrJcB7Hb65+ey5PoX+Bh3GdP2S6u/G7s3j7AAAADpBnw5FFSwj/wAAFHKfCc7v5pqiZttJSwL+MJcePV49aO7qtPM3/B+/jDnNuwUXAH0N2fbm7OYeQ82AAAAAMQGfLXRH/wAAH8gtRbXfatEB8KvllRtffHt6JPOWsCgcHyOUysuwplNnnFTaUo8o8oEAAAAuAZ8vakf/AAAfuaZ/UjL0gMdIs0d67RcY/a5B4l1PcsQIvRSNOdl+x2nYxwmPTAAAAJVBmzRJqEFsmUwIR//94QAAAwOzQkQCwivQFjPwsM+fMcnpVVvSFYug/ma5rNAcT8WiU6oNBxkhPvKm52uzIoyWyvpuHaXi9f7osCnIElQzZkRBFkOUBNuGP1tTMgfzXfrLmCKyDgSKvrathIed9FdaOLX6dnPmEtlDLCvNhp5CcetTRflRNZpkymAUh+XhZMiEN8aHjAAAAEJBn1JFFSwj/wAAFHslVAM7+HZ+JvGxrKT70cjWC+IAhSOUS1ffbefDMY21T5bxAjIr4vT4OObQLxajq0LoYtZu3dEAAAArAZ9xdEf/AAAfyCz/LuIcegBLCaF/qAKr/GQM0gx4AzkGJXXMJcnTpAzUgQAAACQBn3NqR/8AAB+5pn9RemLJosC7xkfyQxD6znUlA1F3YQEmezEAAABXQZt4SahBbJlMCEf//eEAAAMDub/sl+tixytGY216gC4bQEK6gXuXog/DZTYMP/8zYq44zWYescQ88uxO5XsBdw7tBpT09RfpE83+NpG4bkQkzaDqrKMgAAAAO0GflkUVLCP/AAAUdTbtddklCCTprckv6xmvxMK05m/Lkv09VZEI/uhno2Vg4AW4LLPnLepNeVg/APowAAAAJwGftXRH/wAAH8gsg+2MSN8fb4n22+TRR5nWj2sIqYRqeBBap9PRgQAAACkBn7dqR/8AAB8I7h3hiIGGVsk9FWOt7t4EejNG3DeCD8V/Avegdh7SUgAAAHBBm7xJqEFsmUwIT//98QAAAwJJvecddEHbE0gDhuEZhE6TCmWkWDTg8veNhFI/osmNu1jYtt+VwG08/Azei8xAx0ORRcxYtrMkL5Fd8PXi2JJ/jXdF9b1XsVQbUk9T1Q2Lp/0tZWN8xKhfqWillaJkAAAAJEGf2kUVLCP/AAAT4f2RC15p4MX6yijN4MGAy5HD2fcuTwFpNQAAACoBn/l0R/8AAB8Yym4CUWZBnUdf/ONk8VQLpRzamk9uQVNyk4S5JvwhlmAAAAAtAZ/7akf/AAAfCO02vR2eDOTdQEqj8H0AhkY5iU4RO5Eip9GK1DsPqmUN7c5RAAAATUGb4EmoQWyZTAhH//3hAAADA6O/6miqG6fUxYXHJ9o+GmcneWKXhO168xBcMHv/al9stdFA0xexF+ZyZOgDiQFhlVPfhUozT39Mbbt5AAAAJ0GeHkUVLCP/AAAT4i8I+r+6QPpR4vbLqdWEQKmIQ5038GG6pDW99wAAACMBnj10R/8AAB8YLKKkpq4kxSYRl7etFYx/WM+eLilaGx+MFwAAADUBnj9qR/8AAB8WZ0Lc+jKZkCSZ39zky98o4PI4HQnf2u/utkB+oHlw0gAFz+1luIHGwGT7gAAAAGZBmiRJqEFsmUwIT//98QAAAwI5v6cddNqJ2GlIACKLt/dvRNrV5UUA4xVBorwWZUn0QKdaTGZ54MRYUEJbl2T9gHPm+0niDrVxwolDOqD8cKBeX/7oTLbnix70mpfe7nXerewWmN0AAAA9QZ5CRRUsI/8AABNV4Lvs4VI8sMxUaV+4s3UfvmiQ/e2KgFZlDwSazrKj0KYrwkVprQAOM8wgGlqBrd9PuQAAADcBnmF0R/8AAB5oym3/uZB43kxG1En24PtRdAWVALL3jKMp9MZsHKxKOXRRzZ1+ROtG6+gjwBeUAAAAKQGeY2pH/wAAHljs2nDflaiTkKl/YizVqH6imZoeUMektuo2gfHWRWPlAAAAX0GaaEmoQWyZTAhH//3hAAADA42/6miqG6feHWvmXXvnp44gYQdQh9fA5cMbof3aRQu6BMyx3l4Qke7aaCkdFLKdsUaY2f/g22RDi20wBAAa5SCZbN5/gPdiqIW+cHsRAAAAMkGehkUVLCP/AAATVeDL/xto4X8uhr2Ml3wiXQInS4c6jAFzhfEfHSHfEtIclNsBkY9AAAAAKAGepXRH/wAAHmgsoqSmriTFJhGXuA29O2LFnK2NOtXIRDGovRv/9MEAAAAqAZ6nakf/AAAeZmmtxPMDf62CmWNQ7zBh+hbmXnHzq/DhkX/98Nh02fDAAAAAYEGarEmoQWyZTAhP//3xAAADAim/8chLhiSUrU92ndUze+V9/CEI9DBRJfQlvwYoB++Z1m3jxAG8IA4JFGzJbFZEhqBczq9yv6WbH2O77FaQgOcYMfdngyvmaJ8ciLbIrQAAAEdBnspFFSwj/wAAEtXgu+zkBTX8WoTp5LymSyS+cT4iuaGK9DdDm3jvTfAq97RzQQVyL+mi5K4/kRGMSdoPhBv9Ti6Cep98wQAAADIBnul0R/8AAB2mc1R/f/0CetaLklzXe8hq9jd2FyyoHmegeQ2w0VW7g9CPqwNJe22+YQAAADIBnutqR/8AAB2o7Npw35Wok564KLJASZXL0pTfqRQsxIvUFMdxnVW0vTq2iLpS+P72YQAAAHJBmvBJqEFsmUwIT//98QAAAwIt0TWYCpCPkHBNTH/6d7sYUlkx39nLlCUbTiYu4J/BC27H7DFzTRt6a9ad8W7cAM6SKT5fWhIAEZVTVI2fnXJRNUWg5sRtTdeg4yh1FEzOVhetW4BdU915UU3YfRyar+YAAAA8QZ8ORRUsI/8AABLYsvCcalOP9o2RHvOiULNwi62UpN4FewOJvOGwOTeIPE/LZV5wiOAtChB7Snhe1T/8AAAAKgGfLXRH/wAAHaZzFxUOoI3CdHIC4hC4YJ1UOlQFxZ4p17mg4BnhPnsX+QAAADABny9qR/8AAB2si7AkB+SHuAPnXwa+Syjh50AerkUhSflMWYnFsyCDrtq/Kxszf4AAAACVQZs0SahBbJlMCEf//eEAAAMDY7/qaT6FwyXYwfa61aNCUIBYfrFvPMHr5YRtXZ7NgnqG9ZoXlmx32Ls6GWJYs7nP02pl6BauL/nHZYE7oeHeaVazUPa0tj0jfrceO65OCm6U3xsxcM6hZvA/qTRI+MdcEd2kXfGrGfriGyZo7HSeeyV/86EuTthLvg3MVRadMMwsABAAAAA7QZ9SRRUsI/8AABJV+lsVsdhFyYeMsBxKE2HFGhhmafybe62Mlfv96H0LJQmEj4wanM1x2HZxRpuxrdMAAAAzAZ9xdEf/AAAc9c4InYmYV5O15ZxLcAr8+D6nw21apW3Eumh6eaII4uD5EhjdcHOkfT9xAAAALAGfc2pH/wAAHQXyDOJQj7h6qxGRklwGYOQK7ya5xM5TitnyojTiYBW9AcphAAAAnUGbeEmoQWyZTAhH//3hAAADA0oqK53c0hACjM4B1m15XadQsgJRDq8Et1vYckN0eewrz0iaaRC1vH0VSr4fS4ddcObHze+O+77+J+mYkfWdQvjBoHem+pHnuKyfmvBBz2eQ/PBQurUMuKUkHK6F9Uujq2VNyu5uuXXcJWOJ+wKfdrqgnAQQxvyQWMeV/9TYmgtcum6DXBpY/FI5RoAAAABBQZ+WRRUsI/8AABHV+DYnUS0mEh3qD+hIfqg3Z3HSxPXiR+vyqmMjZT8lJTRzgozfETwRdLSBMxJjyeu/ZttHAEAAAAAxAZ+1dEf/AAAcWC0M+rfu9qOKRkAL2DmFwXtgEjRkvNerhSRv+mn+z4fAylmv3Vt9UQAAAC4Bn7dqR/8AABxIBhZ/QEjCDoa2cPKSWH1q+7/jhiQn8kqKiHa6vvPUEd7V9kAQAAAAjUGbukmoQWyZTBRMJ//98QAAAwIN0TXKoCOmAPjfIPIgK/DQ4M4ZUmhHnbYge0gApfpue87HbAAI6YSW32a1daJFXRePooVNpompTpe7tTRf6vtu3HNDIgTi4VpUDGoqMO9YOnyehuUCmjrq64wPeWLhGPhES/A1OqR9QNHX2uc2ztS7uEXAH1fX8Jb4nAAAADQBn9lqR/8AABxMiRwLEEyeccQe8KWhN98OhohuHbnB80jzjhNhgI5WURoX8wuaVrKivHSBAAAAZEGb3knhClJlMCP//IQAAAye/3uDqfvL4wjztrLBlUIZWRkGHUutHu/UHsVvGgyVmPQN27vpe/Ibqotu9Nzw9Ctg/L61u6+4lu/zdaIiotHe8Cnp1cfQC/f+P193Z7/2ulaQF6AAAAA+QZ/8RTRMI/8AABFWANYsQ7eAevJAm8y1De9SsjeNrAciAnadZlFfKMh74PgdSjacipFTFPTwT4cZ+WAwSFkAAAAtAZ4bdEf/AAAbqMTMTp0JQAkuOKsjRL4YmUh52BpJIbCinJkYks74pUwmQ9h5AAAAKAGeHWpH/wAAG5vHLH9DXY/lh4jLIFbQIeax04O30Nme1lHJ1kE3NeIAAABpQZofSahBaJlMCE///fEAAAMB8LJ/Vq6wLpuytk8MnMJAcFHJmHnSvDHZTBrRDGaDL0orxv6aPqaLK+X8Gr/BjfdjgJ4AoPtxmNrqMzELHpQrQJphNGRojNYHAb0siKvkuS7aQqjjFkifAAAAXUGaI0nhClJlMCP//IQAAAxO/35FaTqYCI1t0wwyjzThogzouGao9wHCL2nPCMiYauLFLL4AFnfTh7p9s0z6NOsXkwNf5iOWuuCWHAHKDr+Ni8X0BDdNUQSWRViJLAAAADJBnkFFNEwj/wAAENYJdixDOf/jDnQ6qjax17D6Xo3BQ2PC+yPA+rShckf4tCaj7LvzgQAAADEBnmB0R/8AABr5wwZrN1yb1Yz2/hUw4EJYBa9/g5caYZkqeNlfiupDHsqQauPYUykXAAAAJwGeYmpH/wAAGvvHLNd/1CL76cSKhgjudUC3Ap0h4xPkyna0A9IfwAAAAGdBmmRJqEFomUwIR//94QAAAwMOJKc8OK7TxUvHB/AH+OmqpA2Efk21lmD+g0t1ZgA3PIQ29hMuNi6rxP3MANi0RIJzglKIDmbY9Z1u79428LlnYVI/goPzFrcypuJjDzF0v3+T35GAAAAAZ0Gah0nhClJlMCP//IQAAAv+/3uDP9ZiuADMwff0tLmxi7IJSzE8gJaiDdVjUAIemsSsPM1CI8EKDm8h+gehcYgJ70CZLV0SMByDatOhCC0zUOG+7UYSRetkE1bu6AUG7nTUXdBHNMEAAAArQZ6lRTRMI/8AABBdNoziGdv6J2WJLEVWqG1J3K/wMuENMAAIYjk0cKBJHAAAADABnsZqR/8AABpnl6KDSMp+PqT69MksxHe6/4H0R7Gn0UKxXR6Zhbvwyo6sSAha++EAAABDQZrISahBaJlMCP/8hAAAC5pDvKj4ZNVKeBJ+XHL0sgRgV16FG9WXJYk2Gq2XfZcTQ12ZdKW+10ag6wChlGVR4MDIoAAAAENBmulJ4QpSZTAhP/3xAAADAdm03SDawya9LEEXTeaMp7/q44wjC1wer/pu2FLeX/CEJqSUdpEdigbTvgAseTvXW5SzAAAAQ0GbCknhDomUwIR//eEAAAMC/+jEGFxrePx2xQQio9Crr0IYpRXeYeB6Wqq9Wo7gDIdhiJ57kBXtFZAYhrltNwI1skEAAAIhZYiEADP//vbsvgU1/Z/QlxEsxdpKcD4qpICAdzTAAAOybAAAAwAHLTfHYhYCY5ygAAADA1AAoIWAR4SoWwkI+x0hv+DwyQAIehTk47wxn+uY9joCTFXbFGOgvOyS14lMbNPlKD9V6RBXG5gUdLXnvC78kayw3BynHbIq42e9uL1eKJ5P9+k92JHmljVmY6htdVH6dVrMM5NP6qF7c/nF+CYRHCW77qXzxjLOW8tPX1BUUY+cCflZPKbYvAaDoRQhsocWvpU506fVNKjCMpvPaUILpPxz2GbQfT7jc8d2XCCSkhouYhBq4XDxf7T2870PfhBlarujcn8XuTbjbEReNWca1uHg0U7S4rDj8DVTveQD5fn7zFaiO/UZ7jlP/NCLFyfJ+BKYXBtujr6qMxbNCHStFQYKbUsW0Els/XolYLYj+mKx2ZH4MYXc+7JVjherZiEcm39HgAHJME1Lba1Bmn0b4khBJp6Hi9wy3ROAAeiHl4rl8y/1xQ4NlHH060xvx+ftdjsxqrTWjUN1eNoak1ZTYzKYskOY5At0Pwp+bUXmdTL5aP2vkGedQ9A/iHjuvT6IvbRFbeeltJAjg/DEiPne8soGLxJKjs3/Nbn6MvoMDIQXZYvMDK3DVdRALyJAWm0R1R6JdxKwkczkyA3UNy7yGIRl+k/S/bCQjlMRcDyBj+bev7lNESruQAAxwAAPl5gAAAMAAAMAAAMAAAMAElEAAACMQZokbEI//eEAAAMBk+FcgC82mhympP5BAa6VJxYnCbVYYv4LhbpV9EgbB0d39DCKANMW4WZuKc1vRSML+/GBf889vcLNuMAXy5sSwrNqZGVLREtAsoW5c40iHiP6bH7HJchLag+pD/GN/CWhVhv2D3Sqf8dFdMOtVFtf3f5uZZrn3socjlH4dK3e6GEAAAAvQZ5CeIR/AAADAznBEJMj+2z0oveNn+1TZp+qVbfPILmzeBNwbjKX4YQ4oHU+ibMAAAAbAZ5hdEf/AAANheuEpUopCWNF7bOxpNZpdPOSAAAALAGeY2pH/wAABSCo0PL8dhnVgT767eDyvNK/rvokwo+wi0TDbTOId+qlrrZhAAAAvkGaZ0moQWiZTAhP//3xAAADAp733k2lsGyg1gAG0xgRy5H91I91Ovu8SFMlkEB4d/NvlsUUEFqCeT/0Cu/eqEieQVMZ4TvWXfNWexnuv8DvaVWUNCBxxdAbjRkz2oSQ1XEfslc+hfxW5UQXzWxDef0yVqIu2n3/aokm66IRwS8726hzJN5Uk7EZqkrhdtxF5NjkcEmCDIQj2HZuo1KDTvsmhHZpK7xrLrE/JwY43///UoJKbTkqmpKoAJe004sAAABVQZ6FRREsI/8AABazLAOYdqfKjj5MywAlqUZg5VSdz6pH0cC0tOTrrYRy/rpHhOeDb5mTRAa+eJXV2kC2fegEvahYyU9CmpCa4YdnSTbw5JUo2en2YAAAAC0BnqZqR/8AACO/BCcSyRBmioW+lH1gG7cdq0yX4KBYE2sjWjqm2j6hsm77gMEAAACkQZqrSahBbJlMCE///fEAAAMCn4b/gKFmsupPo5s6PE15VCTg7zfIVKJS+tpxHD9j65dk75CuiQEbP2307B98US6ZS2275xhwrCkO2H7ERADQfhg6ubFo3oMbhhPgMIoiyAiNCxcrW3M5lvcC3eznD66Z8P7K+H8pGZZNy7Usv/vzYZLnCczkojvM8VAka1hN+TnoO0Xz4NLE2VFTKteOmX/recEAAABCQZ7JRRUsI/8AABa1KzoIGzBzWbz49xoC2CxpMFlm9ROW2tez5MAUkLjCLgvTFHmh3DHGlDqt2ZacE3jn1NQwKXXhAAAANAGe6HRH/wAAI8MXafDre9PbE3YZHhxOn/DfTGmHpWtYOklLrLDQUAHx02VyYVohWi/Wr3AAAAAbAZ7qakf/AAAFHmH8+AwL+6v890PU3OQe+puAAAAAT0Ga70moQWyZTAj//IQAAA/Zxj7UGF9EG+xzkaRiM0X59aepodAxllEmyGjgkJsOgyTiQwCY7qDyStj6NmfvuTine2pnUdkXD/vlL11o24EAAAAwQZ8NRRUsI/8AABa8Q83+RmwIhCMLu9BLCQFobEe3FkB7/TVWfnTEPMPjXhlt89rwAAAAKgGfLHRH/wAADX4F3xyBPJe1mAKBvHtlSZ/H+c+xV+YSSHQeQ486T/q1NwAAACsBny5qR/8AACO/BCcNt84cYgk6k4FKtOp5qvQYCXSElPAs+7QjBOrBaguBAAAAbEGbMEmoQWyZTAhH//3hAAAEFlOQYWfPxVNim9VMP632ftKgWNaYEj4x6YQ0eheeNoeiwfK8O0Bj2NcHubSvEYIy2mNrDSgs7J2TGnZTYwvzqukbFVBBXdEfXXHbhKnhuOjOZfqiR5b3Agi1VgAAAFlBm1JJ4QpSZTBRUsK//jhAAAEM+iXOLCnvqM+Kqg6GCQJL83/32R4gdQBydAJ/WfxOJp+mez6c6umMt4hjsowtDb04DwUMSXwSFmamsUSLiiZB/PWFQtRlrwAAACwBn3FqR/8AACOyJx3Iqyi0Gw6JSSoNw9Bt3zdCUgIDXSTCErHnRWcNtfncHwAAAD9Bm3RJ4Q6JlMFEwr/+OEAAAAWMbxJSv6MN8vrO5bYUagpgDk6UkJ7Y/Bp4aeOlKlX+H5ALHYvwYWF403oFt/wAAAAcAZ+Takf/AAADALm8Hx3iITGNLEGnG8q0L8/ZgQAAAHZBm5hJ4Q8mUwIT//3xAAADAPehAWpCtjhJcAEQbNaHyGmjKkE4HgG3fbCMBik/f3wgEyz7O9DyTa91HxlgLtAuZ0yuy38cYxpwCTVKrdAINbeNLk5KQKAOBmj0OUI/3/0hw/hZnazpovgnH4KGT6+uImi2y7tGAAAAM0GftkURPCP/AAAIbAoo3QBD4YnbiXmYmnU0a0dYSGGNq4B+ENCla80Nykt7732ukcbrFQAAABsBn9V0R/8AAA1+EvM5juQwQtg2QFxd5gpRSTEAAAAcAZ/Xakf/AAADAdXxwT+yS20I8+3Dx49JPz0STAAAAJVBm9xJqEFomUwIV//+OEAAAQzxrJfwro14gghiwIOITaQU7th83oYBJjJiAbYVG0dXnspFKT53TnobYbP2RjgrPDw+3IMWEv8mZd3TMlOafFbNVatzAMtZmRX4v+/eRTkzIWNm0pOBLhhqnPAvyCBU0KFHmUodAzarxHnvrSFnvDVYnIxXeEnKQwryHFdyTNZzKnrZTAAAADVBn/pFESwj/wAAFrKfCcDNT1B8mbRZL1RrTPP5goz+B7MLRy1MO4Is/mN1AfZwO6PPZcN7kwAAAB0Bnhl0R/8AACOsOQWu7rUuT+pgyPpZgS+wqQBKgAAAACkBnhtqR/8AACOuMS/PrTgY+WFpvXE4sKY0TTOht+RPE+yMhQuSO1wJWQAAAGxBmgBJqEFsmUwIT//98QAAAwKf7ff+KyIfs+rQ3wGZqQAa4lXY26y9REMZfjqS8y/DkIuo5y8WvD191p35kzmKtbZthT0oZnG2ntpc7nwhENBijck1TolFqrb274KbKECQADQBc88pFh9NuBgAAAAlQZ4+RRUsI/8AABa8Q83PzQbzocX/J4fpdPMOGFOfFhBN8gP6QQAAABEBnl10R/8AAA0uFCqqNYCRgQAAADwBnl9qR/8AACO/BCf5wwAJTXNcw+lNKZhFJ+6N8I4u0zEAgmf/roMgc9Y4wPpIjduks2fzcJuMX1l22YEAAACBQZpESahBbJlMCE///fEAAAMCkcvGR5SyRATf7MZWssl8CZTrRSrvUgthosZbDYi7HXrXtsAbSBWPOH1nr+Ita9w1YE+lwPONXT96z/nS6v12fXmiWVXAD3BzYFIzOblvCmb2ksufaU+JyTfE/tKJHMF6UBqxaRAY81l+x9xdomnrAAAALkGeYkUVLCP/AAAWu4p+XbbidM16V6cvzRWVUf2qBhdY3aBT2FZBsdQ0ZipXy4AAAAAmAZ6BdEf/AAAjwxdoqZ3x7YQKzY9jIAcfvzdegGHl4U1AzTd2yTAAAAAnAZ6Dakf/AAAjvxj0ki923O1cetVPTPTcUAhWr1yXWoTM+UW2l7tnAAAAdEGaiEmoQWyZTAhP//3xAAADAqCs1e6Pp5FwkAAIStOBdVzIezYeuWxceAukyGnRW7QBD4pH+CngRahvrbel6pv9BsV5YxKqXJYN0qgNgiAjw4pvg+rKjLXJK4lJmemq88MWZeUHSnE96XrlO9p0a5sgS5hgAAAALkGepkUVLCP/AAAWvEW+ZLP9s/Omz11orJeEpXn9+2cx3gOIhlJW+G5JKeQL4sAAAAAlAZ7FdEf/AAAirDiADlLjbKzvpltIqs8oLU736s0Oz3ORippHswAAACcBnsdqR/8AACOuMS/SMtOk/JafjuSd4T8p0vaSi2wxSA+ZeqMW6ckAAAB1QZrMSahBbJlMCE///fEAAAMCnwUU8wCmOhSLrbkBjq6prrGR64/71gAi/G94FQCky/+4jm+CKwl6JPHGno/M9i17bDa1TVtxpcG6mTa5malqWKDjvLB4HvLyabngv83M2R8x5yiZmo0T1AuHQBAWq8awZYVtAAAAJEGe6kUVLCP/AAAWtSs0PDh9nKn896pR5d7p5XbzNI35tLwkBAAAADIBnwl0R/8AACOr+FwO2EOK6+Px10KjdI6IrCYPX262QAA2J7lbsHLwDiteawnD18qHJAAAABIBnwtqR/8AAA00npt4YtI0CZkAAABsQZsQSahBbJlMCEf//eEAAAQXNLswh1U5Xbyu57wAC1tFy3YhWn/Z20gpzon55uTuNqP4BsMygM0egcJuG6vTEkVK3OEXVk8EAR34Gb+5dT5BVNgToO+tLpu3wKDzR+H0wOXTtJaz9vCr3hGNAAAAQUGfLkUVLCP/AAAWvEPKZM9tL4nwkfj5w617POGVe+fys0kUFj3BoNdJeEAsxDbpDyVu7QAtSLVNF+ZO+GnEKituAAAAMgGfTXRH/wAADX9FEnkY3ReqGMPmtUmAfB5MOaj/JuqHjnAcW/hR0c6hRZyWGstY0TkhAAAAMQGfT2pH/wAAI78EJMZ/v7Uv9Bg3oXhsPCmBAC2zCrO6kcPdKAQDrvUNyJMQHoY9WTAAAAA9QZtUSahBbJlMCE///fEAAAMCnvfeTaEI7XrW5dEZ53/6nu3boQRSqVhz1X4l6qTyuMr27zY/67G4FDub0QAAACpBn3JFFSwj/wAAFsCbP0d5QG5N86+1k+U4GlEz8jGwStaibhhQYNuSW3EAAAAnAZ+RdEf/AAAjwxdoqZiGDE8YRe79ZhlxTWWUT2eSrRw37KQgHxMcAAAAHgGfk2pH/wAAI78EJxLJaZy/Tgq84w9jQeQnDgglQQAAAEdBm5hJqEFsmUwIR//94QAABBNdwJvwWNwp5PsBFgCRPW15wjLDwuASQW42BPs0SFC1Yyv7c5FbDbPFuqpEBDZ6GualWlAGBgAAADVBn7ZFFSwj/wAAFrMrtQW6D/ylUQbYZEvxg0PYJutfxQvK6WQACGWSwojUCjy6zkYZfaqSTQAAACMBn9V0R/8AACPDF2ipqOjDfK5xVUw0BfUbTU1UPznn3pHbMQAAACsBn9dqR/8AACO/BCcSybg13/EJe1wQAlqNkxNABn2KxRSXECjM12dcWYQEAAAAVEGb2kmoQWyZTBRMJ//98QAAAwKfyGooAjLg6Ux1LcWlmkL5mhXEQ2EUWqYEAvG7Ct0vTr5ZAE5gUjVv4DfbLY8PxSV+CA7o3shsJzpoSyrufPAoIAAAACQBn/lqR/8AACO/BCcR4QtStuiPdN1+Cwf8dQsups3vhCNTg5MAAABPQZv+SeEKUmUwIT/98QAAAwKe995Npkr+aCv3QAQ7kzTksAFtYS7/ByP0TZJ6uA0NOHQnt2OmUx/SHQmVVvlpZrJlQYyLoLo6ayQ+6SBswAAAACpBnhxFNEwj/wAAFsCbPsKhgXUKOc4ysZgLCXz/biOp4kJv6Z9XiLw1XbcAAAAhAZ47dEf/AAAjwxdoqaV5Pbr+teglsIU6srNpxUSk3n2YAAAAHQGePWpH/wAAI78EJxLJaa1ZMA4me8PDDo2bA9mBAAAAYkGaIkmoQWiZTAhP//3xAAADAp732G5Le7kJ11SHPjl2kTIAkiSapkAEp49rWJYypLkPVIEEMeoSEJ5d4lPXCstKGO2oCql8qAhB0FIANcSCVYRbQTYsRdOH9g1zE+kgiGJrAAAAMUGeQEURLCP/AAAWsytU74oIZ2wnfdgTams/RtW2mNlLNakGJ4ug03HY/+UL9KWveDEAAAAdAZ5/dEf/AAAjq/hbcbxLGCHRlO9QxMcKlfO4Uk0AAAA2AZ5hakf/AAAjscvjUBeuDd6LVmKgAOvIJeLYXbRDidbFtwIYpemf8VAB9gn24r+0WxC456wuAAAASEGaZkmoQWyZTAhP//3xAAADAPl5n0G5kkV+pkovoC/OmnebHSK80Fat9+FjeaIBErN3JXlKlDRaTEXQh8izueTnAMzxKwRFgAAAACpBnoRFFSwj/wAACCwMtBbmBnxpsDjhytpNS53i4RFdN8N1shp46VDNbcEAAAAxAZ6jdEf/AAANdPciTEvJ0YvOMp9eDTLJ3a3dIhPyu1co7TMUVvoc4DlACmg6Fl/tmAAAACQBnqVqR/8AAAUOEauRDcrpZBDfTuQVNUsBXPNoM7mevgjQtmAAAABTQZqqSahBbJlMCEf//eEAAAQbompregTdDgY5+4OFThBhcg4LENshyu7V4Cj+jvOyxqEnwBdg5TdBFYL/N/ZYqE+OeTS22pLht4P2vc4U+Fkt4xkAAAA+QZ7IRRUsI/8AABa8Q821UlZIHAAcbWL07GdpOL0GqotyI50JhCObpwkZA8jQsW1rC9UqYxxvaILPKiLzjkkAAAAiAZ7ndEf/AAAFH9DBt0t3jnAMZ+kJTgZ5mmbgdrh8udW8kQAAADUBnulqR/8AACOxwQ3Gfrgywot/9PVCDqzbGCAHv0J44Iw8usIAF5ogBAAtdwOBJTgmB7xqjAAAAH1Bmu5JqEFsmUwIT//98QAAAwKM6VjwAkZ5bs7sgATqowy0e1hVRqjDul5OE/bG4g234pNb4DZIGW/7wUuur7RNSA8rVdtsdYFArV3HQooxfM96dL/xpF8FVnTrrGxb8Uysm5d9fxwsWMASPkxeYQRADIbhrGUkFWiSPrnCQAAAAD1BnwxFFSwj/wAAFitfhA2Xa8wFYlPr9JCXav5dAuh7AMDpb/0mSYQ3vaRaRnjq0uPcvrWnYw/RWDRO3tmBAAAAKQGfK3RH/wAAIsC5kNKRtvTUpXnsX5de8Ut1QtJJN+xDfUM6NHybJ3tuAAAAGQGfLWpH/wAAIr8azntt5YvtuYa00jex0DAAAABSQZsySahBbJlMCE///fEAAAMA8qCKyEWrBAQb/UYtWTvdwd0knpnR8NV//buFs/yyVWHHJvF6CticB51ZEbiadu3/ojuZlPt/LvWdw3zwd2XyoQAAAEFBn1BFFSwj/wAACC/ifKOe7TnA0bulvLd1YP+fBirr3Wsv0EwY2+OSCebnDNMUzBiADd76CMJn44+aE+ufQOhRWAAAACwBn290R/8AAA033yDXvsS/iz/f10TbdhqhLsjtgIl3vjlRZkMvqMIboWkkwQAAADIBn3FqR/8AAA01gtNytcmgAliowug2Snl36BYVfHPK401YhMpQizWOCyV71ETE6t0/lQAAAEJBm3ZJqEFsmUwIR//94QAAAwP1TY4b70T+WL7/kt+jCUT77mZARSg/w2IqIAj4GbacHOX4iWsme2BewJedlnttOOAAAAAnQZ+URRUsI/8AABYjLAOigrEWIo0cms6mIOZM7K+atz6xZLprVlmxAAAAIgGfs3RH/wAAIsM+DaDXZxKaLJEsVBc0jrmzsXJ6yfIF5CwAAAAeAZ+1akf/AAAivwQnEslprVO/zCQq4LpeCGyJ2t6BAAAAVEGbukmoQWyZTAhH//3hAAADA/dvi37riPwgCJoQdv/J4ChsYRlq/InnBR33+65dxazij9lKmbE9msDzrwfzM+S2xx6vggSqz1QnwjqYrMP2/eSvgQAAAEtBn9hFFSwj/wAAFiUrOWdMWJ8JAAli0o6xuDWXt7afq9DSUYrupCic6My6PJUx7t+aE6XF7MRuNOEanrdvlqo2IvGxs/JnVMpm3oAAAAAoAZ/3dEf/AAAiqc7FkWyV3f9/tlXLTkORDBRKUirzNrb1A0r1LV8TcAAAADMBn/lqR/8AAAzf22KYikROpinLt6iBRGM52gnHsIbslHJIdgaFqu+zHeACUu0qsEAtC3sAAABeQZv+SahBbJlMCE///fEAAAMCjPfeTagGvYkwfd16RV+3MCXJcPUygBUDJhSPc04pe4OebVR+KG5dxVdTc2DQ/BOeqPuoHZCGtEPF7JV8gmJDKZT9LdYPtI/8xgrAgAAAACdBnhxFFSwj/wAAFiMrtQW5HC/l0Id31u7gGUMdnxj9Ev1TD+Lyt6EAAAAjAZ47dEf/AAAiq/hPt1uH6GAmm2W0RpmhAUWciPIvEPdX8mwAAAAcAZ49akf/AAAiscwJb6lvshnelLwSs58K5Rp0wQAAAGRBmiJJqEFsmUwIR//94QAAAwP1PqZS+rUDHiABGQNfY4SjFRlWIpgPoLQZulRbaxv2QMQNsypBLDbrYOWBe0BsHtHCHXd+h3aTHqz/Bd6MMKwfMGQSNc4JLz6aurDoBAkimms1AAAAPEGeQEUVLCP/AAAWIp7eNyS8qzrgNzmfMgYykgjBf1bWWxLySACdtYl+ZEypItL3CY213Vk7uWo3VBVwQQAAACYBnn90R/8AACLAuN/Ay6Q94UpDJLJldajj4kB45npYClno6YdvQQAAACkBnmFqR/8AACKuMS/R3NTz9ZBCNHu9fsp58Oq+KGOp091ySHnKkBBvwAAAAFRBmmZJqEFsmUwIR//94QAAAwP1YPWkUGKup7UA0VCc7ltgASEgbkI5tg8vtfHJdEn6RNcZvXqp6kB+qXHIw9uJ5QBlJYO40GCTYXL/71/5Mi1WG5gAAABLQZ6ERRUsI/8AABYlKzl4smIjJzZjmPSdVcoLimpsy5v1tzinj7SYZfDZu7JpCiz57ZU7N/AsoABDLeDYXoHIncVS03y5kY9VLPBBAAAAJAGeo3RH/wAAIsMXajWJvdImGrVmA0L8uZgqiAXsY0ThHPqnwAAAAC4BnqVqR/8AAAzf22L1i5KGQNJB47oxPB35N0R7DYG4ppAh5jd6S9HHsF3IRPk2AAAAYkGaqkmoQWyZTAhH//3hAAADA/u/6mZYbpeC/Mu1+uoh+0ixcAAas5Gr7JRF2e7ohbHcjN90zGjrxjE0hBOPRrMdJKZsdEFZYsFxv62gl828iXxzSs+7oDG069lruz7bOZbBAAAAPEGeyEUVLCP/AAAWJSX9TD8PUAevGAL+2nWaw8n9yL+ejCSrSoB19cl544vrBtEE+kALfaEJHVoSCWPiwQAAADABnud0R/8AACKsFQ4JtkEow1a798nd53tG5ux3HLQgBaUkUK+9YtG0uqMnEOYTgdMAAAAiAZ7pakf/AAAhvZaECJBpbIPcDTTRG8zyYrvlEgTfQkC7gAAAADJBmu1JqEFsmUwI//yEAAAPI+bWeBBkHtxaqc0GoyEj+4eHAS7l9ZI+QfbW19EHKqErcAAAADJBnwtFFSwj/wAAFZxOnU6ud6zoGBxJND9NxORgK3+gLGRLTfxNJLoXKmnqj5Ar31m3oQAAAB8BnyxqR/8AACGuMvr9EIzY7AiD4tdfFMIDBim1ayU+AAAAMEGbLkmoQWyZTAj//IQAAAXK7J0XqOAT+wXXmkiLB6iYkSCYrVDQTxcThx7AXOBXFAAAGidtb292AAAAbG12aGQAAAAAAAAAAAAAAAAAAAPoAAAnJAABAAABAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAZUXRyYWsAAABcdGtoZAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAnJAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAEAAAAACWAAAAZAAAAAAACRlZHRzAAAAHGVsc3QAAAAAAAAAAQAAJyQAAAIAAAEAAAAAGMltZGlhAAAAIG1kaGQAAAAAAAAAAAAAAAAAADIAAAH1AFXEAAAAAAAtaGRscgAAAAAAAAAAdmlkZQAAAAAAAAAAAAAAAFZpZGVvSGFuZGxlcgAAABh0bWluZgAAABR2bWhkAAAAAQAAAAAAAAAAAAAAJGRpbmYAAAAcZHJlZgAAAAAAAAABAAAADHVybCAAAAABAAAYNHN0YmwAAACYc3RzZAAAAAAAAAABAAAAiGF2YzEAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAACWAGQAEgAAABIAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY//8AAAAyYXZjQwFkAB//4QAZZ2QAH6zZQJgz5eEAAAMAAQAAAwBkDxgxlgEABmjr48siwAAAABhzdHRzAAAAAAAAAAEAAAH1AAABAAAAABxzdHNzAAAAAAAAAAMAAAABAAAAvAAAAYcAAA9IY3R0cwAAAAAAAAHnAAAAAQAAAgAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAAAwAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAIAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAAAwAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAAAwAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAEAAAAAAIAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABAAAAAACAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABAAAAAACAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAQAAAAAAgAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAMAAAAAAQAAAQAAAAABAAAEAAAAAAIAAAEAAAAAAQAABAAAAAACAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAAAgAAAAABAAAEAAAAAAIAAAEAAAAAAQAABAAAAAACAAABAAAAAAEAAAIAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAADAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAACAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAAAgAAAAABAAAEAAAAAAIAAAEAAAAABAAAAgAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAQAAAAAAgAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAAAgAAAAABAAADAAAAAAEAAAEAAAAAAQAAAwAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAMAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAEAAAAAAIAAAEAAAAAAQAAAgAAAAAcc3RzYwAAAAAAAAABAAAAAQAAAfUAAAABAAAH6HN0c3oAAAAAAAAAAAAAAfUAAAThAAAAvAAAAEAAAAA2AAAAMwAAAG0AAABGAAAAHwAAAEoAAAB2AAAAMgAAAHMAAAAzAAAAHwAAABwAAACnAAAARQAAACAAAABBAAAAWgAAACgAAAAVAAAANAAAAHQAAABgAAAAOwAAACgAAAAbAAAAhgAAADMAAAAqAAAAOAAAAEwAAABKAAAAKAAAAC0AAABnAAAAMgAAAEIAAAAkAAAAKQAAABIAAACjAAAAPQAAACoAAAAhAAAAOAAAAFEAAAA5AAAALgAAAHEAAAA/AAAAMwAAAC4AAABxAAAANwAAAFYAAABBAAAAQgAAACYAAACKAAAANwAAAC4AAAAjAAAAdAAAAC8AAAAvAAAAPgAAAFAAAABFAAAAJgAAADAAAABTAAAALwAAACYAAAAgAAAAYgAAADgAAAAhAAAAOAAAAFcAAAAyAAAAPQAAAB0AAABMAAAANwAAACIAAAAsAAAAQgAAAEYAAAAkAAAAJQAAAGgAAAA8AAAALgAAACIAAACEAAAARgAAACwAAAAwAAAAcQAAADEAAAAsAAAAMwAAADAAAAAmAAAAPgAAAD4AAACOAAAARAAAACwAAAAsAAAAdwAAADIAAAApAAAAOwAAAC8AAAArAAAAJwAAAIsAAABDAAAALgAAACwAAABRAAAALwAAACsAAAA6AAAAawAAAEEAAAArAAAAOQAAAFgAAAAxAAAAMgAAAC8AAAB8AAAAOQAAACgAAAAlAAAAeQAAADQAAAAnAAAAQwAAAEQAAAArAAAAKAAAAGQAAAArAAAAKQAAAIkAAAAtAAAAPwAAACcAAACFAAAATAAAAC0AAAA7AAAAfQAAADwAAAA9AAAALwAAAF8AAAA2AAAAMAAAAIQAAABAAAAASgAAADwAAABvAAAAMQAAAHYAAAA0AAAAOgAAAI8AAAA7AAAAKgAAAHMAAAAyAAAAOQAAADsAAABZAAAAcwAAADMAAAA4AAAAaQAAADAAAAA4AAACKwAAAGUAAAAhAAAAIQAAABIAAADKAAAAPQAAADIAAAA6AAAAdAAAAC4AAAA7AAAAIQAAAJYAAAA+AAAAMQAAAC4AAACxAAAAPwAAADUAAAA9AAAAaAAAAEgAAAAiAAAAOAAAANcAAAA8AAAANAAAADUAAADEAAAANwAAAC0AAAAtAAAATQAAACsAAAAgAAAAHwAAAHwAAABFAAAAPAAAACUAAABRAAAAMAAAADcAAAA0AAAAhQAAAD0AAAAuAAAAOwAAAEkAAAA0AAAAHAAAADEAAABIAAAAKQAAACMAAAAaAAAAUgAAADIAAAAwAAAAOgAAAEYAAAAwAAAAJAAAACsAAAA/AAAAPAAAACoAAAAcAAAAWQAAAD8AAAAoAAAARQAAAFcAAAAuAAAAKwAAACMAAABRAAAANgAAADUAAAA3AAAAgQAAADoAAAAsAAAALAAAAGMAAAA2AAAAMAAAAC4AAABWAAAANQAAADAAAAAqAAAAagAAAEAAAAAqAAAAMwAAAF8AAAAoAAAANAAAACEAAACUAAAAQwAAACYAAAAmAAAARgAAACwAAAAdAAAAKAAAAHUAAAAtAAAAGQAAACoAAABgAAAAOwAAADcAAAA1AAAASQAAADAAAAAmAAAAMQAAAIcAAAAvAAAAKgAAADAAAABsAAAALgAAACkAAAArAAAAVAAAADcAAAAtAAAAKAAAAF8AAABLAAAAJQAAACoAAABpAAAAKgAAACMAAAA0AAAAWgAAAD4AAAA1AAAAMgAAAJkAAABGAAAALwAAACgAAABbAAAAPwAAACsAAAAtAAAAdAAAACgAAAAuAAAAMQAAAFEAAAArAAAAJwAAADkAAABqAAAAQQAAADsAAAAtAAAAYwAAADYAAAAsAAAALgAAAGQAAABLAAAANgAAADYAAAB2AAAAQAAAAC4AAAA0AAAAmQAAAD8AAAA3AAAAMAAAAKEAAABFAAAANQAAADIAAACRAAAAOAAAAGgAAABCAAAAMQAAACwAAABtAAAAYQAAADYAAAA1AAAAKwAAAGsAAABrAAAALwAAADQAAABHAAAARwAAAEcAAAIlAAAAkAAAADMAAAAfAAAAMAAAAMIAAABZAAAAMQAAAKgAAABGAAAAOAAAAB8AAABTAAAANAAAAC4AAAAvAAAAcAAAAF0AAAAwAAAAQwAAACAAAAB6AAAANwAAAB8AAAAgAAAAmQAAADkAAAAhAAAALQAAAHAAAAApAAAAFQAAAEAAAACFAAAAMgAAACoAAAArAAAAeAAAADIAAAApAAAAKwAAAHkAAAAoAAAANgAAABYAAABwAAAARQAAADYAAAA1AAAAQQAAAC4AAAArAAAAIgAAAEsAAAA5AAAAJwAAAC8AAABYAAAAKAAAAFMAAAAuAAAAJQAAACEAAABmAAAANQAAACEAAAA6AAAATAAAAC4AAAA1AAAAKAAAAFcAAABCAAAAJgAAADkAAACBAAAAQQAAAC0AAAAdAAAAVgAAAEUAAAAwAAAANgAAAEYAAAArAAAAJgAAACIAAABYAAAATwAAACwAAAA3AAAAYgAAACsAAAAnAAAAIAAAAGgAAABAAAAAKgAAAC0AAABYAAAATwAAACgAAAAyAAAAZgAAAEAAAAA0AAAAJgAAADYAAAA2AAAAIwAAADQAAAAUc3RjbwAAAAAAAAABAAAAMAAAAGJ1ZHRhAAAAWm1ldGEAAAAAAAAAIWhkbHIAAAAAAAAAAG1kaXJhcHBsAAAAAAAAAAAAAAAALWlsc3QAAAAlqXRvbwAAAB1kYXRhAAAAAQAAAABMYXZmNTguMjkuMTAw\" type=\"video/mp4\">\n",
       "        </video>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Helper function to record videos for sb3 model\n",
    "def record_video_sb3(env_id, video_folder, video_length, model):\n",
    "\n",
    "    vec_env = DummyVecEnv([lambda: gym.make(env_id, render_mode=\"rgb_array\")])\n",
    "    # Record the video starting at the first step\n",
    "    vec_env = VecVideoRecorder(vec_env, video_folder,\n",
    "                           record_video_trigger=lambda x: x == 0, video_length=video_length,\n",
    "                           name_prefix=f\"{type(agent).__name__}-{env_id}\")\n",
    "\n",
    "    obs = vec_env.reset()\n",
    "    for _ in range(video_length + 1):\n",
    "        action, _state = model.predict(obs)\n",
    "        obs, _, _, _ = vec_env.step(action)\n",
    "    # video filename\n",
    "    file_path = \"./\"+video_folder+vec_env.video_recorder.path.split(\"/\")[-1]\n",
    "    # Save the video\n",
    "    vec_env.close()\n",
    "    return file_path\n",
    "\n",
    "\n",
    "video_folder = \"logs/6_a/sb3/videos/\"\n",
    "video_length = 500\n",
    "\n",
    "video_file_sb3 = record_video_sb3(env_name, video_folder, video_length, model)\n",
    "play_video(video_file_sb3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zT2wXhynlNvW"
   },
   "source": [
    "#### Share the agent using HuggingFace"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Hrmg8oPOlNvW"
   },
   "source": [
    "Get your Hugging Face token ready as we will need in next code cell to be able to login into your hugging face account\n",
    "\n",
    "**Enter your Token**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 145,
     "referenced_widgets": [
      "11a42b7711f2472db6c9f05b697390cd",
      "73ec67c0e09d4bb0b7758012408bc99b",
      "b293121597f8442b951f260db5fa77d4",
      "4bc6579073c445e593c74227774f19ee",
      "21145d76a7e24644acbc55d87c935d24",
      "18b5099ea6754704a7413d850478ed9e",
      "ede351d45bac43db8fc76a894fcfacf0",
      "8c1f86e0b62d44ee96df8420284ee0e9",
      "9c6de0d8f8b84a0aa239c1d549b4d999",
      "5a251c49122d495893ee95026a5f5c58",
      "a964a4d69eb74a6aae5750c577915ca0",
      "38a421e00dff415094cfcaf9b42e6c87",
      "983c23d230954debb757b9e425d76531",
      "ab20961674f14a8cba2bfe814e48c25c",
      "834a9d2efe174c7d9ff72d3277919fd2",
      "13bfe3534cd44a5285e8468047b5f693",
      "cc3569e5d5044030b73a8bbb32c961e3",
      "9fdc8261f8e64d4ea995e783dba61cbd",
      "b48b14bdbf574dcebc6930558a5ad035",
      "f086412ef371478f87d981796e0a51f6",
      "bf51823cc5f84ed1a34dc3779ac7b173",
      "2f19a722ab4041dab88d362f16dbb200",
      "bed2844d22664a00811964c91a03cdd6",
      "9ef1ccf4e0e14f8f806962d72c7574e5",
      "6ba119043fd04129a619b09cf9cf8c0d",
      "0189405cd3f94bf7bd35913a0a890c13",
      "f8910f13f12f42eb8518f539136fa90c",
      "1f2869485d6e4cc0afc1cf1f39500eb3",
      "a96c4337763e48c88591f6a183770c4a",
      "0e9e596b2fa546f8a35e32fe31db028a",
      "e2157c13296a43afa159d6996c5a8753",
      "00a35b9fb31b44e888d17102ef7dc281"
     ]
    },
    "id": "6NUqoutplNvW",
    "outputId": "add83c7d-5a54-4d89-fb43-a3657f1a5556"
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2f98fdb6d7ae480abdc7caa871c7f406",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(HTML(value='<center> <img\\nsrc=https://huggingface.co/front/assets/huggingface_logo-noborder.sv…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from huggingface_sb3 import load_from_hub, package_to_hub, push_to_hub\n",
    "from huggingface_hub import notebook_login # To log to our Hugging Face account to be able to upload models to the Hub.\n",
    "\n",
    "notebook_login()\n",
    "!git config --global credential.helper store"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**IMPORTANT**\n",
    "Some users have reported facing following error while running the `package_to_hub` upload function. \n",
    "\n",
    "```\n",
    "\"Token is required (write-access action) but no token found. You need to provide a token or be logged in to Hugging Face with `huggingface-cli login` or `huggingface_hub.login`. See https://huggingface.co/settings/tokens.\"\n",
    "```\n",
    "\n",
    "In such a case the following command will help you over come the issue\n",
    "\n",
    "```\n",
    "import huggingface_hub\n",
    "\n",
    "huggingface_hub.login(token= <YOUR_HF_TOKEN>,\n",
    "                     write_permission = True,\n",
    "                    add_to_git_credential = True)\n",
    "\t\t\t\t\t\n",
    "```\n",
    "\n",
    "Another alternative is to use following command from command shell where the `venv` or `conda` environment for this repository has been activated and then follow the instructions to set the HuggingFace token.\n",
    "\n",
    "```\n",
    "huggingface-cli login\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 426,
     "referenced_widgets": [
      "c5b76670d2554feeb632a3013aca2962",
      "d77d049d43b34989a7b150446b2a87e2",
      "0d85825c1689408685a26cb2db3126f4",
      "a79a2fb3f81e4214bd69d563ccbb91c6",
      "bc315f24524848c4a9bc940bfb00a959",
      "8fac41ff159a47b69e35230f519da9a7",
      "b25455a01a364331a71f427e45b8d566",
      "b9101353863f465d88d9c21e4ca92f07",
      "a0e86af7f02f4e968857f6283d2c5fdd",
      "83a01ff27a5e4a6792bc8de4d590f65a",
      "4c1c9a99b72d4914813016cc3c0c0120",
      "74769575b5d54624bf2f27b79da53ceb",
      "1cbc7e0ebc5047f5a61a80b519ebce41",
      "a55f0be1d4e5423a9b59907bbf39de68",
      "784f54d24898436b99d5ea528084818d",
      "b7a8d44c22464af88da030b844ad21b8",
      "de4841ea039b4117a03fb05ac455194f",
      "914ffdd6feb14f4a9f61f4de076c77f9",
      "63bb34cf28dd46609e286dc4d597656c",
      "620cb12fe87543048b142d5c057e0c21",
      "a17785a5694846b899944437d401d4da",
      "ee1d7c957f484533aaf1a034ba3987fa",
      "b9c91a633fa6434c864411a79f5edfbf",
      "e380bd88e6524613bf782090d8372e0c",
      "8f708d5f4041454195bef849e5153324",
      "6e5da7aecf794c0cac1dfd17236a325e",
      "c803d98649064086916e72d630f55ef3",
      "45005e8941d04abb9ced51bbc2d838cb",
      "e1117f6bdaec48b2a24c103daf4181b4",
      "7ae36bb772bf4f1ebcc17a502dd3f225",
      "63f2cafdc4a84bd981c66e605dd974cc",
      "bd7e4a6b879341bda592ea3c00ba6b0c",
      "0cfbdbacc76a4b0199006b521e3a8650",
      "d6a18ae8bfc44987a1298820cf0caab2",
      "96647e54ce954f63b43b8177dd28d704",
      "5a81f7cec2cc47c59e33e9e9c94eb872",
      "8fdb412710684e07a56a7f2ac85bcd54",
      "8d2715edba2f408d8aca3f1e0ea1f530",
      "a46148600bed4f61a43fb844cd156665",
      "a067e9850d1c43b188b0a1e9a2303a72",
      "4e7dd242ae574110a9b2884b30946492",
      "5c987bce21bc462d97383e2769bc1fa4",
      "1ae68f5b0bcd470bb087ba94367113f6",
      "43c442a374224e27a1a043bcea0a43ee"
     ]
    },
    "id": "adO9mcnAlNvW",
    "outputId": "a32ed9a1-0881-4c22-8ba0-deaab9a3ae96"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[38;5;4mℹ This function will save, evaluate, generate a video of your agent,\n",
      "create a model card and push everything to the hub. It might take up to 1min.\n",
      "This is a work in progress: if you encounter a bug, please open an issue.\u001b[0m\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/nsanghi/sandbox/apress/drl-2ed/venv/lib/python3.10/site-packages/stable_baselines3/common/evaluation.py:67: UserWarning: Evaluation environment is not wrapped with a ``Monitor`` wrapper. This may result in reporting modified episode lengths and rewards, if other wrappers happen to modify these. Consider wrapping environment first with ``Monitor`` wrapper.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saving video to /tmp/tmpqw6ghbj0/-step-0-to-step-1000.mp4\n",
      "Moviepy - Building video /tmp/tmpqw6ghbj0/-step-0-to-step-1000.mp4.\n",
      "Moviepy - Writing video /tmp/tmpqw6ghbj0/-step-0-to-step-1000.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                                                        \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready /tmp/tmpqw6ghbj0/-step-0-to-step-1000.mp4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "ffmpeg version 4.4.2-0ubuntu0.22.04.1 Copyright (c) 2000-2021 the FFmpeg developers\n",
      "  built with gcc 11 (Ubuntu 11.2.0-19ubuntu1)\n",
      "  configuration: --prefix=/usr --extra-version=0ubuntu0.22.04.1 --toolchain=hardened --libdir=/usr/lib/x86_64-linux-gnu --incdir=/usr/include/x86_64-linux-gnu --arch=amd64 --enable-gpl --disable-stripping --enable-gnutls --enable-ladspa --enable-libaom --enable-libass --enable-libbluray --enable-libbs2b --enable-libcaca --enable-libcdio --enable-libcodec2 --enable-libdav1d --enable-libflite --enable-libfontconfig --enable-libfreetype --enable-libfribidi --enable-libgme --enable-libgsm --enable-libjack --enable-libmp3lame --enable-libmysofa --enable-libopenjpeg --enable-libopenmpt --enable-libopus --enable-libpulse --enable-librabbitmq --enable-librubberband --enable-libshine --enable-libsnappy --enable-libsoxr --enable-libspeex --enable-libsrt --enable-libssh --enable-libtheora --enable-libtwolame --enable-libvidstab --enable-libvorbis --enable-libvpx --enable-libwebp --enable-libx265 --enable-libxml2 --enable-libxvid --enable-libzimg --enable-libzmq --enable-libzvbi --enable-lv2 --enable-omx --enable-openal --enable-opencl --enable-opengl --enable-sdl2 --enable-pocketsphinx --enable-librsvg --enable-libmfx --enable-libdc1394 --enable-libdrm --enable-libiec61883 --enable-chromaprint --enable-frei0r --enable-libx264 --enable-shared\n",
      "  libavutil      56. 70.100 / 56. 70.100\n",
      "  libavcodec     58.134.100 / 58.134.100\n",
      "  libavformat    58. 76.100 / 58. 76.100\n",
      "  libavdevice    58. 13.100 / 58. 13.100\n",
      "  libavfilter     7.110.100 /  7.110.100\n",
      "  libswscale      5.  9.100 /  5.  9.100\n",
      "  libswresample   3.  9.100 /  3.  9.100\n",
      "  libpostproc    55.  9.100 / 55.  9.100\n",
      "Input #0, mov,mp4,m4a,3gp,3g2,mj2, from '/tmp/tmpqw6ghbj0/-step-0-to-step-1000.mp4':\n",
      "  Metadata:\n",
      "    major_brand     : isom\n",
      "    minor_version   : 512\n",
      "    compatible_brands: isomiso2avc1mp41\n",
      "    encoder         : Lavf58.29.100\n",
      "  Duration: 00:00:20.02, start: 0.000000, bitrate: 31 kb/s\n",
      "  Stream #0:0(und): Video: h264 (High) (avc1 / 0x31637661), yuv420p, 600x400, 26 kb/s, 50 fps, 50 tbr, 12800 tbn, 100 tbc (default)\n",
      "    Metadata:\n",
      "      handler_name    : VideoHandler\n",
      "      vendor_id       : [0][0][0][0]\n",
      "Stream mapping:\n",
      "  Stream #0:0 -> #0:0 (h264 (native) -> h264 (libx264))\n",
      "Press [q] to stop, [?] for help\n",
      "[libx264 @ 0x55c5f2a5a5c0] using cpu capabilities: MMX2 SSE2Fast SSSE3 SSE4.2 AVX FMA3 BMI2 AVX2\n",
      "[libx264 @ 0x55c5f2a5a5c0] profile High, level 3.1, 4:2:0, 8-bit\n",
      "[libx264 @ 0x55c5f2a5a5c0] 264 - core 163 r3060 5db6aa6 - H.264/MPEG-4 AVC codec - Copyleft 2003-2021 - http://www.videolan.org/x264.html - options: cabac=1 ref=3 deblock=1:0:0 analyse=0x3:0x113 me=hex subme=7 psy=1 psy_rd=1.00:0.00 mixed_ref=1 me_range=16 chroma_me=1 trellis=1 8x8dct=1 cqm=0 deadzone=21,11 fast_pskip=1 chroma_qp_offset=-2 threads=12 lookahead_threads=2 sliced_threads=0 nr=0 decimate=1 interlaced=0 bluray_compat=0 constrained_intra=0 bframes=3 b_pyramid=2 b_adapt=1 b_bias=0 direct=1 weightb=1 open_gop=0 weightp=2 keyint=250 keyint_min=25 scenecut=40 intra_refresh=0 rc_lookahead=40 rc=crf mbtree=1 crf=23.0 qcomp=0.60 qpmin=0 qpmax=69 qpstep=4 ip_ratio=1.40 aq=1:1.00\n",
      "Output #0, mp4, to '/tmp/tmpq0gap3bo/replay.mp4':\n",
      "  Metadata:\n",
      "    major_brand     : isom\n",
      "    minor_version   : 512\n",
      "    compatible_brands: isomiso2avc1mp41\n",
      "    encoder         : Lavf58.76.100\n",
      "  Stream #0:0(und): Video: h264 (avc1 / 0x31637661), yuv420p(progressive), 600x400, q=2-31, 50 fps, 12800 tbn (default)\n",
      "    Metadata:\n",
      "      handler_name    : VideoHandler\n",
      "      vendor_id       : [0][0][0][0]\n",
      "      encoder         : Lavc58.134.100 libx264\n",
      "    Side data:\n",
      "      cpb: bitrate max/min/avg: 0/0/0 buffer size: 0 vbv_delay: N/A\n",
      "frame= 1001 fps=460 q=-1.0 Lsize=      77kB time=00:00:19.96 bitrate=  31.6kbits/s speed=9.18x    \n",
      "video:65kB audio:0kB subtitle:0kB other streams:0kB global headers:0kB muxing overhead: 19.161133%\n",
      "[libx264 @ 0x55c5f2a5a5c0] frame I:6     Avg QP: 8.63  size:   539\n",
      "[libx264 @ 0x55c5f2a5a5c0] frame P:276   Avg QP:18.55  size:   100\n",
      "[libx264 @ 0x55c5f2a5a5c0] frame B:719   Avg QP:17.79  size:    48\n",
      "[libx264 @ 0x55c5f2a5a5c0] consecutive B-frames:  2.2%  3.6%  7.5% 86.7%\n",
      "[libx264 @ 0x55c5f2a5a5c0] mb I  I16..4: 96.5%  1.2%  2.3%\n",
      "[libx264 @ 0x55c5f2a5a5c0] mb P  I16..4:  0.2%  0.2%  0.0%  P16..4:  1.7%  0.4%  0.1%  0.0%  0.0%    skip:97.4%\n",
      "[libx264 @ 0x55c5f2a5a5c0] mb B  I16..4:  0.0%  0.0%  0.0%  B16..8:  1.9%  0.2%  0.0%  direct: 0.0%  skip:97.8%  L0:48.8% L1:50.7% BI: 0.5%\n",
      "[libx264 @ 0x55c5f2a5a5c0] 8x8 transform intra:9.1% inter:12.7%\n",
      "[libx264 @ 0x55c5f2a5a5c0] coded y,uvDC,uvAC intra: 1.6% 3.4% 2.4% inter: 0.0% 0.1% 0.0%\n",
      "[libx264 @ 0x55c5f2a5a5c0] i16 v,h,dc,p: 90%  6%  4%  0%\n",
      "[libx264 @ 0x55c5f2a5a5c0] i8 v,h,dc,ddl,ddr,vr,hd,vl,hu:  7%  8% 85%  0%  0%  0%  0%  0%  0%\n",
      "[libx264 @ 0x55c5f2a5a5c0] i4 v,h,dc,ddl,ddr,vr,hd,vl,hu: 56% 14% 28%  1%  0%  0%  0%  1%  0%\n",
      "[libx264 @ 0x55c5f2a5a5c0] i8c dc,h,v,p: 89%  1% 10%  0%\n",
      "[libx264 @ 0x55c5f2a5a5c0] Weighted P-Frames: Y:0.0% UV:0.0%\n",
      "[libx264 @ 0x55c5f2a5a5c0] ref P L0: 70.4%  1.4% 16.7% 11.5%\n",
      "[libx264 @ 0x55c5f2a5a5c0] ref B L0: 80.3% 15.9%  3.8%\n",
      "[libx264 @ 0x55c5f2a5a5c0] ref B L1: 94.5%  5.5%\n",
      "[libx264 @ 0x55c5f2a5a5c0] kb/s:26.14\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[38;5;4mℹ Pushing repo nsanghi/dqn-cart-pole-sb3 to the Hugging Face Hub\u001b[0m\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "612060aa1d9a49158903c14c3456f768",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "policy.pth:   0%|          | 0.00/545k [00:00<?, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b3f5208202774b28afa37a736881b11c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "DQN-CartPole-v1.zip:   0%|          | 0.00/1.11M [00:00<?, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2f08d574a82f45bda5bcdab70d158fc5",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "policy.optimizer.pth:   0%|          | 0.00/546k [00:00<?, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2ba9cbb0549a4b579977f8407798a1c9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Upload 3 LFS files:   0%|          | 0/3 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[38;5;4mℹ Your model is pushed to the Hub. You can view your model here:\n",
      "https://huggingface.co/nsanghi/dqn-cart-pole-sb3/tree/main/\u001b[0m\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'https://huggingface.co/nsanghi/dqn-cart-pole-sb3/tree/main/'"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eval_env = DummyVecEnv([lambda: gym.make(env_name, render_mode=\"rgb_array\")])\n",
    "obs = eval_env.reset()\n",
    "\n",
    "# method save, evaluate, generate a model card and record a replay video of your agent before pushing the repo to the hub\n",
    "\n",
    "# Please note repo_id is of the form <huggingface_id>/<name of repo>\n",
    "# you will need to change this to \"<your_huggingface_id>/dqn-cart-pole-v1\"\n",
    "\n",
    "package_to_hub(model=model, # Our trained model\n",
    "               model_name= \"DQN-\" + env_name, # The name of our trained model\n",
    "               model_architecture=\"DQN\", # The model architecture we used: in our case PPO\n",
    "               env_id=env_name, # Name of the environment\n",
    "               eval_env=eval_env, # Evaluation Environment\n",
    "               repo_id=\"nsanghi/dqn-cart-pole-sb3\", # id of the model repository from the Hugging Face Hub (repo_id = {organization}/{repo_name}\n",
    "               commit_message=\"Push to Hub\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mG4cjOo3lNvX"
   },
   "source": [
    "### Train using RL_Zoo3\n",
    "We will also be using Weights and Biases to records the run and other experiment details. For this we need to login using the wandb api key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 121
    },
    "id": "F0KdOWwulNvX",
    "outputId": "6366dad7-5714-49b9-d796-0a890a5f7c81"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[34m\u001b[1mwandb\u001b[0m: Currently logged in as: \u001b[33mnsanghi\u001b[0m. Use \u001b[1m`wandb login --relogin`\u001b[0m to force relogin\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import wandb\n",
    "wandb.login()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**IMPORTANT**\n",
    "In case you face a login error with `wandb.login()`, please run the following cell by setting first your wandb api key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "os.environ[\"WANDB_API_KEY\"] = \"Your WANDB_API_KEY......\"\n",
    "import wandb\n",
    "wandb.login()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "69xbQdJ_lNvY"
   },
   "source": [
    "#### Train agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "UUPgk8A3lNvY",
    "outputId": "9c8cface-068b-44ca-b132-c63e96ae8778"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2023-11-05 07:26:07.477717: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
      "2023-11-05 07:26:07.572782: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
      "2023-11-05 07:26:07.572879: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
      "2023-11-05 07:26:07.572990: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
      "2023-11-05 07:26:07.610548: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 AVX_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2023-11-05 07:26:09.104862: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n",
      "========== CartPole-v1 ==========\n",
      "Seed: 2652168140\n",
      "\u001b[34m\u001b[1mwandb\u001b[0m: Currently logged in as: \u001b[33mnsanghi\u001b[0m. Use \u001b[1m`wandb login --relogin`\u001b[0m to force relogin\n",
      "\u001b[34m\u001b[1mwandb\u001b[0m: Tracking run with wandb version 0.15.12\n",
      "\u001b[34m\u001b[1mwandb\u001b[0m: Run data is saved locally in \u001b[35m\u001b[1m/home/nsanghi/sandbox/apress/drl-2ed/chapter6/wandb/run-20231105_072614-iegpeibb\u001b[0m\n",
      "\u001b[34m\u001b[1mwandb\u001b[0m: Run \u001b[1m`wandb offline`\u001b[0m to turn off syncing.\n",
      "\u001b[34m\u001b[1mwandb\u001b[0m: Syncing run \u001b[33mCartPole-v1__dqn__2652168140__1699149373\u001b[0m\n",
      "\u001b[34m\u001b[1mwandb\u001b[0m: ⭐️ View project at \u001b[34m\u001b[4mhttps://wandb.ai/nsanghi/dqn-cartpole\u001b[0m\n",
      "\u001b[34m\u001b[1mwandb\u001b[0m: 🚀 View run at \u001b[34m\u001b[4mhttps://wandb.ai/nsanghi/dqn-cartpole/runs/iegpeibb\u001b[0m\n",
      "Loading hyperparameters from: /home/nsanghi/sandbox/apress/drl-2ed/venv/lib/python3.10/site-packages/rl_zoo3/hyperparams/dqn.yml\n",
      "Default hyperparameters for environment (ones being tuned will be overridden):\n",
      "OrderedDict([('batch_size', 64),\n",
      "             ('buffer_size', 100000),\n",
      "             ('exploration_final_eps', 0.04),\n",
      "             ('exploration_fraction', 0.16),\n",
      "             ('gamma', 0.99),\n",
      "             ('gradient_steps', 128),\n",
      "             ('learning_rate', 0.0023),\n",
      "             ('learning_starts', 1000),\n",
      "             ('n_timesteps', 50000.0),\n",
      "             ('policy', 'MlpPolicy'),\n",
      "             ('policy_kwargs', 'dict(net_arch=[256, 256])'),\n",
      "             ('target_update_interval', 10),\n",
      "             ('train_freq', 256)])\n",
      "Using 1 environments\n",
      "Creating test environment\n",
      "Using cpu device\n",
      "Log path: logs/6_a/rlzoo3//dqn/CartPole-v1_3\n",
      "Logging to runs/CartPole-v1__dqn__2652168140__1699149373/CartPole-v1/DQN_1\n",
      "\u001b[2K\u001b[35m   2%\u001b[0m \u001b[91m╸\u001b[0m\u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m881/50,000 \u001b[0m [ \u001b[33m0:00:00\u001b[0m < \u001b[36m-:--:--\u001b[0m , \u001b[31m? it/s\u001b[0m ]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-11-05 07:26:16.357955: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
      "2023-11-05 07:26:16.478176: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
      "2023-11-05 07:26:16.478346: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
      "2023-11-05 07:26:16.478410: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
      "2023-11-05 07:26:16.503307: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 AVX_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[2K\u001b[35m   2%\u001b[0m \u001b[91m╸\u001b[0m\u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m881/50,000 \u001b[0m [ \u001b[33m0:00:03\u001b[0m < \u001b[36m-:--:--\u001b[0m , \u001b[31m? it/s\u001b[0m ]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-11-05 07:26:19.073112: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[2KEval num_timesteps=10000, episode_reward=103.10 +/- 3.14━━━━━━━━━\u001b[0m \u001b[32m9,977/50,000 \u001b[0m [ \u001b[33m0:00:39\u001b[0m < \u001b[36m0:02:54\u001b[0m , \u001b[31m231 it/s\u001b[0m ]\n",
      "\u001b[2KEpisode length: 103.10 +/- 3.14\u001b[0m\u001b[90m━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m9,977/50,000 \u001b[0m [ \u001b[33m0:00:39\u001b[0m < \u001b[36m0:02:54\u001b[0m , \u001b[31m231 it/s\u001b[0m ]\n",
      "\u001b[2K----------------------------------m\u001b[90m━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m9,977/50,000 \u001b[0m [ \u001b[33m0:00:39\u001b[0m < \u001b[36m0:02:54\u001b[0m , \u001b[31m231 it/s\u001b[0m ]\n",
      "| eval/               |          |\n",
      "|    mean_ep_length   | 103      |\n",
      "|    mean_reward      | 103      |\n",
      "| rollout/            |          |\n",
      "|    exploration_rate | 0.04     |\n",
      "| time/               |          |\n",
      "|    total_timesteps  | 10000    |\n",
      "| train/              |          |\n",
      "|    learning_rate    | 0.0023   |\n",
      "|    loss             | 0.247    |\n",
      "|    n_updates        | 4608     |\n",
      "----------------------------------\n",
      "\u001b[2KNew best mean reward!\u001b[0m\u001b[90m╺\u001b[0m\u001b[90m━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m9,977/50,000 \u001b[0m [ \u001b[33m0:00:39\u001b[0m < \u001b[36m0:02:54\u001b[0m , \u001b[31m231 it/s\u001b[0m ]\n",
      "\u001b[2KEval num_timesteps=20000, episode_reward=124.60 +/- 3.58━━━━━━━━\u001b[0m \u001b[32m19,934/50,000 \u001b[0m [ \u001b[33m0:01:36\u001b[0m < \u001b[36m0:02:56\u001b[0m , \u001b[31m171 it/s\u001b[0m ]\n",
      "\u001b[2KEpisode length: 124.60 +/- 3.58[90m╺\u001b[0m\u001b[90m━━━━━━━━━━━━━━━\u001b[0m \u001b[32m19,934/50,000 \u001b[0m [ \u001b[33m0:01:36\u001b[0m < \u001b[36m0:02:56\u001b[0m , \u001b[31m171 it/s\u001b[0m ]\n",
      "\u001b[2K----------------------------------m╺\u001b[0m\u001b[90m━━━━━━━━━━━━━━━\u001b[0m \u001b[32m19,934/50,000 \u001b[0m [ \u001b[33m0:01:36\u001b[0m < \u001b[36m0:02:56\u001b[0m , \u001b[31m171 it/s\u001b[0m ]\n",
      "| eval/               |          |\n",
      "|    mean_ep_length   | 125      |\n",
      "|    mean_reward      | 125      |\n",
      "| rollout/            |          |\n",
      "|    exploration_rate | 0.04     |\n",
      "| time/               |          |\n",
      "|    total_timesteps  | 20000    |\n",
      "| train/              |          |\n",
      "|    learning_rate    | 0.0023   |\n",
      "|    loss             | 0.275    |\n",
      "|    n_updates        | 9600     |\n",
      "----------------------------------\n",
      "\u001b[2KNew best mean reward!━━━━━\u001b[0m\u001b[90m╺\u001b[0m\u001b[90m━━━━━━━━━━━━━━━\u001b[0m \u001b[32m19,934/50,000 \u001b[0m [ \u001b[33m0:01:36\u001b[0m < \u001b[36m0:02:56\u001b[0m , \u001b[31m171 it/s\u001b[0m ]\n",
      "\u001b[2KEval num_timesteps=30000, episode_reward=500.00 +/- 0.00━━━━━━━━\u001b[0m \u001b[32m29,953/50,000 \u001b[0m [ \u001b[33m0:02:36\u001b[0m < \u001b[36m0:01:47\u001b[0m , \u001b[31m189 it/s\u001b[0m ]\n",
      "\u001b[2KEpisode length: 500.00 +/- 0.00\u001b[0m\u001b[91m╸\u001b[0m\u001b[90m━━━━━━━━━━\u001b[0m \u001b[32m29,953/50,000 \u001b[0m [ \u001b[33m0:02:36\u001b[0m < \u001b[36m0:01:47\u001b[0m , \u001b[31m189 it/s\u001b[0m ]\n",
      "\u001b[2K----------------------------------m\u001b[91m╸\u001b[0m\u001b[90m━━━━━━━━━━\u001b[0m \u001b[32m29,953/50,000 \u001b[0m [ \u001b[33m0:02:36\u001b[0m < \u001b[36m0:01:47\u001b[0m , \u001b[31m189 it/s\u001b[0m ]\n",
      "| eval/               |          |\n",
      "|    mean_ep_length   | 500      |\n",
      "|    mean_reward      | 500      |\n",
      "| rollout/            |          |\n",
      "|    exploration_rate | 0.04     |\n",
      "| time/               |          |\n",
      "|    total_timesteps  | 30000    |\n",
      "| train/              |          |\n",
      "|    learning_rate    | 0.0023   |\n",
      "|    loss             | 0.328    |\n",
      "|    n_updates        | 14592    |\n",
      "----------------------------------\n",
      "\u001b[2KNew best mean reward!━━━━━━━━━━\u001b[0m\u001b[91m╸\u001b[0m\u001b[90m━━━━━━━━━━\u001b[0m \u001b[32m29,953/50,000 \u001b[0m [ \u001b[33m0:02:36\u001b[0m < \u001b[36m0:01:47\u001b[0m , \u001b[31m189 it/s\u001b[0m ]\n",
      "\u001b[2K----------------------------------━━\u001b[0m\u001b[91m╸\u001b[0m\u001b[90m━━━━━━━━━\u001b[0m \u001b[32m32,687/50,000 \u001b[0m [ \u001b[33m0:02:52\u001b[0m < \u001b[36m0:01:40\u001b[0m , \u001b[31m175 it/s\u001b[0m ]\n",
      "| rollout/            |          |\n",
      "|    ep_len_mean      | 166      |\n",
      "|    ep_rew_mean      | 166      |\n",
      "|    exploration_rate | 0.04     |\n",
      "| time/               |          |\n",
      "|    episodes         | 400      |\n",
      "|    fps              | 189      |\n",
      "|    time_elapsed     | 172      |\n",
      "|    total_timesteps  | 32780    |\n",
      "| train/              |          |\n",
      "|    learning_rate    | 0.0023   |\n",
      "|    loss             | 0.361    |\n",
      "|    n_updates        | 16000    |\n",
      "----------------------------------\n",
      "\u001b[2KEval num_timesteps=40000, episode_reward=500.00 +/- 0.0090m━━━━━\u001b[0m \u001b[32m39,915/50,000 \u001b[0m [ \u001b[33m0:03:35\u001b[0m < \u001b[36m0:00:55\u001b[0m , \u001b[31m184 it/s\u001b[0m ]\n",
      "\u001b[2KEpisode length: 500.00 +/- 0.00━━━━━\u001b[0m\u001b[91m╸\u001b[0m\u001b[90m━━━━━\u001b[0m \u001b[32m39,915/50,000 \u001b[0m [ \u001b[33m0:03:35\u001b[0m < \u001b[36m0:00:55\u001b[0m , \u001b[31m184 it/s\u001b[0m ]\n",
      "\u001b[2K----------------------------------━━\u001b[0m\u001b[91m╸\u001b[0m\u001b[90m━━━━━\u001b[0m \u001b[32m39,915/50,000 \u001b[0m [ \u001b[33m0:03:35\u001b[0m < \u001b[36m0:00:55\u001b[0m , \u001b[31m184 it/s\u001b[0m ]\n",
      "| eval/               |          |\n",
      "|    mean_ep_length   | 500      |\n",
      "|    mean_reward      | 500      |\n",
      "| rollout/            |          |\n",
      "|    exploration_rate | 0.04     |\n",
      "| time/               |          |\n",
      "|    total_timesteps  | 40000    |\n",
      "| train/              |          |\n",
      "|    learning_rate    | 0.0023   |\n",
      "|    loss             | 0.36     |\n",
      "|    n_updates        | 19584    |\n",
      "----------------------------------\n",
      "\u001b[2KEval num_timesteps=50000, episode_reward=456.70 +/- 34.670m \u001b[32m49,948/50,000 \u001b[0m [ \u001b[33m0:04:38\u001b[0m < \u001b[36m0:00:01\u001b[0m , \u001b[31m168 it/s\u001b[0m ]t/s\u001b[0m ]\n",
      "\u001b[2KEpisode length: 456.70 +/- 34.67━━━━━━━━━\u001b[0m\u001b[91m╸\u001b[0m \u001b[32m49,948/50,000 \u001b[0m [ \u001b[33m0:04:38\u001b[0m < \u001b[36m0:00:01\u001b[0m , \u001b[31m168 it/s\u001b[0m ]\n",
      "\u001b[2K----------------------------------━━━━━━━\u001b[0m\u001b[91m╸\u001b[0m \u001b[32m49,948/50,000 \u001b[0m [ \u001b[33m0:04:38\u001b[0m < \u001b[36m0:00:01\u001b[0m , \u001b[31m168 it/s\u001b[0m ]\n",
      "| eval/               |          |\n",
      "|    mean_ep_length   | 457      |\n",
      "|    mean_reward      | 457      |\n",
      "| rollout/            |          |\n",
      "|    exploration_rate | 0.04     |\n",
      "| time/               |          |\n",
      "|    total_timesteps  | 50000    |\n",
      "| train/              |          |\n",
      "|    learning_rate    | 0.0023   |\n",
      "|    loss             | 0.222    |\n",
      "|    n_updates        | 24576    |\n",
      "----------------------------------\n",
      "\u001b[2K\u001b[35m 100%\u001b[0m \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m50,176/50,000 \u001b[0m [ \u001b[33m0:04:38\u001b[0m < \u001b[36m0:00:00\u001b[0m , \u001b[31m150 it/s\u001b[0m ]t/s\u001b[0m ]\n",
      "\u001b[?25hSaving to logs/6_a/rlzoo3//dqn/CartPole-v1_3\n"
     ]
    }
   ],
   "source": [
    "!python -m rl_zoo3.train --algo dqn --env CartPole-v1 --save-freq 10000 \\\n",
    "--eval-freq 10000 --eval-episodes 10 --log-interval 400 --progress \\\n",
    "--track --wandb-project-name dqn-cartpole -f logs/6_a/rlzoo3/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "b6-_-IyKlNvY"
   },
   "source": [
    "#### Evaluate Trained agent\n",
    "Print the performance of the trained agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "C3JLD3JilNvY",
    "outputId": "847f9420-9c35-4fda-ffa9-aab5bb8b83da"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2023-11-05 07:31:50.601203: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
      "2023-11-05 07:31:50.640818: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
      "2023-11-05 07:31:50.640917: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
      "2023-11-05 07:31:50.640947: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
      "2023-11-05 07:31:50.648997: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 AVX_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2023-11-05 07:31:51.887750: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n",
      "Loading latest experiment, id=3\n",
      "Loading logs/6_a/rlzoo3/dqn/CartPole-v1_3/CartPole-v1.zip\n",
      "Episode Reward: 500.00\n",
      "Episode Length 500\n",
      "Episode Reward: 500.00\n",
      "Episode Length 500\n",
      "Episode Reward: 500.00\n",
      "Episode Length 500\n",
      "Episode Reward: 500.00\n",
      "Episode Length 500\n",
      "Episode Reward: 500.00\n",
      "Episode Length 500\n",
      "Episode Reward: 500.00\n",
      "Episode Length 500\n",
      "Episode Reward: 500.00\n",
      "Episode Length 500\n",
      "Episode Reward: 500.00\n",
      "Episode Length 500\n",
      "Episode Reward: 500.00\n",
      "Episode Length 500\n",
      "Episode Reward: 500.00\n",
      "Episode Length 500\n",
      "10 Episodes\n",
      "Mean reward: 500.00 +/- 0.00\n",
      "Mean episode length: 500.00 +/- 0.00\n"
     ]
    }
   ],
   "source": [
    "!python -m rl_zoo3.enjoy --algo dqn --env CartPole-v1 --no-render --n-timesteps 5000 --folder logs/6_a/rlzoo3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ckS-EEXOlNvZ"
   },
   "source": [
    "#### Record a video\n",
    "Let us now record and play a video of a trained agent. We use rl_zoo for generating the video and then use our custom function to play the video"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "rnnDXsy8lNvZ",
    "outputId": "8969dee1-582a-499a-ad68-8c4013de1684"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2023-11-05 23:41:25.831407: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
      "2023-11-05 23:41:25.833703: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n",
      "2023-11-05 23:41:25.866601: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
      "2023-11-05 23:41:25.866672: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
      "2023-11-05 23:41:25.866693: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
      "2023-11-05 23:41:25.873054: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n",
      "2023-11-05 23:41:25.873288: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 AVX_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2023-11-05 23:41:26.522053: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n",
      "Loading latest experiment, id=4\n",
      "Loading logs/6_a/rlzoo3/dqn/CartPole-v1_4/CartPole-v1.zip\n",
      "Loading logs/6_a/rlzoo3/dqn/CartPole-v1_4/CartPole-v1.zip\n",
      "Saving video to /home/nsanghi/sandbox/apress/drl-2ed/chapter6/logs/6_a/rlzoo3/dqn/CartPole-v1_4/videos/final-model-dqn-CartPole-v1-step-0-to-step-1000.mp4\n",
      "Moviepy - Building video /home/nsanghi/sandbox/apress/drl-2ed/chapter6/logs/6_a/rlzoo3/dqn/CartPole-v1_4/videos/final-model-dqn-CartPole-v1-step-0-to-step-1000.mp4.\n",
      "Moviepy - Writing video /home/nsanghi/sandbox/apress/drl-2ed/chapter6/logs/6_a/rlzoo3/dqn/CartPole-v1_4/videos/final-model-dqn-CartPole-v1-step-0-to-step-1000.mp4\n",
      "\n",
      "Moviepy - Done !                                                                \n",
      "Moviepy - video ready /home/nsanghi/sandbox/apress/drl-2ed/chapter6/logs/6_a/rlzoo3/dqn/CartPole-v1_4/videos/final-model-dqn-CartPole-v1-step-0-to-step-1000.mp4\n"
     ]
    }
   ],
   "source": [
    "!python -m rl_zoo3.record_video --algo dqn --env CartPole-v1 --exp-id 0 -f logs/6_a/rlzoo3/ -n 1000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 288
    },
    "id": "JkXQq32ZlNvZ",
    "outputId": "3238871a-c3d0-4886-da15-e18e3b2798a9"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <video width=400 controls>\n",
       "              <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\">\n",
       "        </video>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "video_file_rlzoo = \"logs/6_a/rlzoo3/dqn/CartPole-v1_1/videos/final-model-dqn-CartPole-v1-step-0-to-step-1000.mp4\"\n",
    "play_video(video_file_rlzoo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "cMiC5pr7lNvZ"
   },
   "source": [
    "#### Share on HuggingFace\n",
    "This time we will use the `pust_to_hub` function from `rl_zoo3` to push the trained agent to Huggingface Hub. When you run, the `organization` name has to point to your own huggingface user name.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "RTJCUWeolNvZ",
    "outputId": "bf791e9d-1847-4a14-bcf9-3f382f84b730"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2023-11-05 07:32:55.229136: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
      "2023-11-05 07:32:55.275385: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
      "2023-11-05 07:32:55.275466: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
      "2023-11-05 07:32:55.275494: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
      "2023-11-05 07:32:55.282165: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 AVX_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2023-11-05 07:32:56.013827: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n",
      "Loading latest experiment, id=3\n",
      "Loading logs/6_a/rlzoo3/dqn/CartPole-v1_3/best_model.zip\n",
      "Uploading to nsanghi/dqn-cart-pole-rlzoo, make sure to have the rights\n",
      "\u001b[38;5;4mℹ This function will save, evaluate, generate a video of your agent,\n",
      "create a model card and push everything to the hub. It might take up to some\n",
      "minutes if video generation is activated. This is a work in progress: if you\n",
      "encounter a bug, please open an issue.\u001b[0m\n",
      "/home/nsanghi/sandbox/apress/drl-2ed/chapter6/hub/dqn-cart-pole-rlzoo is already a clone of https://huggingface.co/nsanghi/dqn-cart-pole-rlzoo. Make sure you pull the latest changes with `repo.git_pull()`.\n",
      "Saving model to: hub/dqn-cart-pole-rlzoo/dqn-CartPole-v1\n",
      "Saving video to /tmp/tmpcioqkt9p/-step-0-to-step-1000.mp4\n",
      "Moviepy - Building video /tmp/tmpcioqkt9p/-step-0-to-step-1000.mp4.\n",
      "Moviepy - Writing video /tmp/tmpcioqkt9p/-step-0-to-step-1000.mp4\n",
      "\n",
      "Moviepy - Done !                                                                \n",
      "Moviepy - video ready /tmp/tmpcioqkt9p/-step-0-to-step-1000.mp4\n",
      "ffmpeg version 4.4.2-0ubuntu0.22.04.1 Copyright (c) 2000-2021 the FFmpeg developers\n",
      "  built with gcc 11 (Ubuntu 11.2.0-19ubuntu1)\n",
      "  configuration: --prefix=/usr --extra-version=0ubuntu0.22.04.1 --toolchain=hardened --libdir=/usr/lib/x86_64-linux-gnu --incdir=/usr/include/x86_64-linux-gnu --arch=amd64 --enable-gpl --disable-stripping --enable-gnutls --enable-ladspa --enable-libaom --enable-libass --enable-libbluray --enable-libbs2b --enable-libcaca --enable-libcdio --enable-libcodec2 --enable-libdav1d --enable-libflite --enable-libfontconfig --enable-libfreetype --enable-libfribidi --enable-libgme --enable-libgsm --enable-libjack --enable-libmp3lame --enable-libmysofa --enable-libopenjpeg --enable-libopenmpt --enable-libopus --enable-libpulse --enable-librabbitmq --enable-librubberband --enable-libshine --enable-libsnappy --enable-libsoxr --enable-libspeex --enable-libsrt --enable-libssh --enable-libtheora --enable-libtwolame --enable-libvidstab --enable-libvorbis --enable-libvpx --enable-libwebp --enable-libx265 --enable-libxml2 --enable-libxvid --enable-libzimg --enable-libzmq --enable-libzvbi --enable-lv2 --enable-omx --enable-openal --enable-opencl --enable-opengl --enable-sdl2 --enable-pocketsphinx --enable-librsvg --enable-libmfx --enable-libdc1394 --enable-libdrm --enable-libiec61883 --enable-chromaprint --enable-frei0r --enable-libx264 --enable-shared\n",
      "  libavutil      56. 70.100 / 56. 70.100\n",
      "  libavcodec     58.134.100 / 58.134.100\n",
      "  libavformat    58. 76.100 / 58. 76.100\n",
      "  libavdevice    58. 13.100 / 58. 13.100\n",
      "  libavfilter     7.110.100 /  7.110.100\n",
      "  libswscale      5.  9.100 /  5.  9.100\n",
      "  libswresample   3.  9.100 /  3.  9.100\n",
      "  libpostproc    55.  9.100 / 55.  9.100\n",
      "Input #0, mov,mp4,m4a,3gp,3g2,mj2, from '/tmp/tmpcioqkt9p/-step-0-to-step-1000.mp4':\n",
      "  Metadata:\n",
      "    major_brand     : isom\n",
      "    minor_version   : 512\n",
      "    compatible_brands: isomiso2avc1mp41\n",
      "    encoder         : Lavf58.29.100\n",
      "  Duration: 00:00:20.02, start: 0.000000, bitrate: 20 kb/s\n",
      "  Stream #0:0(und): Video: h264 (High) (avc1 / 0x31637661), yuv420p, 600x400, 15 kb/s, 50 fps, 50 tbr, 12800 tbn, 100 tbc (default)\n",
      "    Metadata:\n",
      "      handler_name    : VideoHandler\n",
      "      vendor_id       : [0][0][0][0]\n",
      "Stream mapping:\n",
      "  Stream #0:0 -> #0:0 (h264 (native) -> h264 (libx264))\n",
      "Press [q] to stop, [?] for help\n",
      "\u001b[1;36m[libx264 @ 0x55c2262e2340] \u001b[0musing cpu capabilities: MMX2 SSE2Fast SSSE3 SSE4.2 AVX FMA3 BMI2 AVX2\n",
      "\u001b[1;36m[libx264 @ 0x55c2262e2340] \u001b[0mprofile High, level 3.1, 4:2:0, 8-bit\n",
      "\u001b[1;36m[libx264 @ 0x55c2262e2340] \u001b[0m264 - core 163 r3060 5db6aa6 - H.264/MPEG-4 AVC codec - Copyleft 2003-2021 - http://www.videolan.org/x264.html - options: cabac=1 ref=3 deblock=1:0:0 analyse=0x3:0x113 me=hex subme=7 psy=1 psy_rd=1.00:0.00 mixed_ref=1 me_range=16 chroma_me=1 trellis=1 8x8dct=1 cqm=0 deadzone=21,11 fast_pskip=1 chroma_qp_offset=-2 threads=12 lookahead_threads=2 sliced_threads=0 nr=0 decimate=1 interlaced=0 bluray_compat=0 constrained_intra=0 bframes=3 b_pyramid=2 b_adapt=1 b_bias=0 direct=1 weightb=1 open_gop=0 weightp=2 keyint=250 keyint_min=25 scenecut=40 intra_refresh=0 rc_lookahead=40 rc=crf mbtree=1 crf=23.0 qcomp=0.60 qpmin=0 qpmax=69 qpstep=4 ip_ratio=1.40 aq=1:1.00\n",
      "Output #0, mp4, to 'hub/dqn-cart-pole-rlzoo/replay.mp4':\n",
      "  Metadata:\n",
      "    major_brand     : isom\n",
      "    minor_version   : 512\n",
      "    compatible_brands: isomiso2avc1mp41\n",
      "    encoder         : Lavf58.76.100\n",
      "  Stream #0:0(und): Video: h264 (avc1 / 0x31637661), yuv420p(progressive), 600x400, q=2-31, 50 fps, 12800 tbn (default)\n",
      "    Metadata:\n",
      "      handler_name    : VideoHandler\n",
      "      vendor_id       : [0][0][0][0]\n",
      "      encoder         : Lavc58.134.100 libx264\n",
      "    Side data:\n",
      "      cpb: bitrate max/min/avg: 0/0/0 buffer size: 0 vbv_delay: N/A\n",
      "frame= 1001 fps=432 q=-1.0 Lsize=      50kB time=00:00:19.96 bitrate=  20.7kbits/s speed=8.62x    \n",
      "video:38kB audio:0kB subtitle:0kB other streams:0kB global headers:0kB muxing overhead: 33.217995%\n",
      "\u001b[1;36m[libx264 @ 0x55c2262e2340] \u001b[0mframe I:5     Avg QP:10.83  size:   461\n",
      "\u001b[1;36m[libx264 @ 0x55c2262e2340] \u001b[0mframe P:252   Avg QP:15.66  size:    52\n",
      "\u001b[1;36m[libx264 @ 0x55c2262e2340] \u001b[0mframe B:744   Avg QP:16.24  size:    30\n",
      "\u001b[1;36m[libx264 @ 0x55c2262e2340] \u001b[0mconsecutive B-frames:  0.7%  0.4%  0.6% 98.3%\n",
      "\u001b[1;36m[libx264 @ 0x55c2262e2340] \u001b[0mmb I  I16..4: 88.9%  9.4%  1.7%\n",
      "\u001b[1;36m[libx264 @ 0x55c2262e2340] \u001b[0mmb P  I16..4:  0.1%  0.0%  0.0%  P16..4:  1.0%  0.1%  0.0%  0.0%  0.0%    skip:98.7%\n",
      "\u001b[1;36m[libx264 @ 0x55c2262e2340] \u001b[0mmb B  I16..4:  0.0%  0.0%  0.0%  B16..8:  1.2%  0.0%  0.0%  direct: 0.0%  skip:98.8%  L0:57.9% L1:41.8% BI: 0.3%\n",
      "\u001b[1;36m[libx264 @ 0x55c2262e2340] \u001b[0m8x8 transform intra:9.2% inter:23.7%\n",
      "\u001b[1;36m[libx264 @ 0x55c2262e2340] \u001b[0mcoded y,uvDC,uvAC intra: 1.1% 2.3% 1.5% inter: 0.0% 0.0% 0.0%\n",
      "\u001b[1;36m[libx264 @ 0x55c2262e2340] \u001b[0mi16 v,h,dc,p: 90%  6%  4%  0%\n",
      "\u001b[1;36m[libx264 @ 0x55c2262e2340] \u001b[0mi8 v,h,dc,ddl,ddr,vr,hd,vl,hu: 46% 10% 43%  0%  0%  0%  0%  0%  0%\n",
      "\u001b[1;36m[libx264 @ 0x55c2262e2340] \u001b[0mi4 v,h,dc,ddl,ddr,vr,hd,vl,hu: 53% 18% 27%  0%  0%  1%  0%  0%  0%\n",
      "\u001b[1;36m[libx264 @ 0x55c2262e2340] \u001b[0mi8c dc,h,v,p: 89%  1% 10%  0%\n",
      "\u001b[1;36m[libx264 @ 0x55c2262e2340] \u001b[0mWeighted P-Frames: Y:0.0% UV:0.0%\n",
      "\u001b[1;36m[libx264 @ 0x55c2262e2340] \u001b[0mref P L0: 42.4%  0.5% 49.1%  7.9%\n",
      "\u001b[1;36m[libx264 @ 0x55c2262e2340] \u001b[0mref B L0: 81.1% 10.4%  8.5%\n",
      "\u001b[1;36m[libx264 @ 0x55c2262e2340] \u001b[0mref B L1: 94.8%  5.2%\n",
      "\u001b[1;36m[libx264 @ 0x55c2262e2340] \u001b[0mkb/s:15.20\n",
      "\u001b[38;5;4mℹ Pushing repo dqn-cart-pole-rlzoo to the Hugging Face Hub\u001b[0m\n",
      "Upload file dqn-CartPole-v1.zip:   3%|▍            | 32.0k/1.06M [00:00<?, ?B/s]\n",
      "Upload file train_eval_metrics.zip: 100%|██████████| 10.3k/10.3k [00:00<?, ?B/s]\u001b[A\n",
      "\n",
      "Upload file dqn-CartPole-v1/policy.pth:   6%|▍      | 32.0k/532k [00:00<?, ?B/s]\u001b[A\u001b[A\n",
      "\n",
      "\n",
      "Upload file replay.mp4:  64%|█████████████▉        | 32.0k/50.4k [00:00<?, ?B/s]\u001b[A\u001b[A\u001b[A\n",
      "\n",
      "\n",
      "\n",
      "Upload file dqn-CartPole-v1/policy.optimizer.pth:   6%| | 32.0k/533k [00:00<?, ?\u001b[A\u001b[A\u001b[A\u001b[ATo https://huggingface.co/nsanghi/dqn-cart-pole-rlzoo\n",
      "   c44c918..8a3e520  main -> main\n",
      "\n",
      "Upload file dqn-CartPole-v1.zip: 100%|██████| 1.06M/1.06M [00:04<00:00, 268kB/s]\n",
      "\n",
      "Upload file train_eval_metrics.zip: 100%|██████████| 10.3k/10.3k [00:04<?, ?B/s]\u001b[A\n",
      "Upload file train_eval_metrics.zip: 100%|██████████| 10.3k/10.3k [00:04<?, ?B/s]\u001b[A\n",
      "\n",
      "\n",
      "Upload file dqn-CartPole-v1/policy.pth: 100%|█| 532k/532k [00:04<00:00, 128kB/s]\u001b[A\u001b[A\n",
      "\n",
      "Upload file dqn-CartPole-v1/policy.pth: 100%|█| 532k/532k [00:04<00:00, 128kB/s]\u001b[A\u001b[A\n",
      "\n",
      "\n",
      "\n",
      "Upload file replay.mp4: 100%|██████████████| 50.4k/50.4k [00:04<00:00, 4.69kB/s]\u001b[A\u001b[A\u001b[A\n",
      "\n",
      "\n",
      "Upload file replay.mp4: 100%|██████████████| 50.4k/50.4k [00:04<00:00, 4.69kB/s]\u001b[A\u001b[A\u001b[A\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "Upload file dqn-CartPole-v1/policy.optimizer.pth: 100%|█| 533k/533k [00:04<00:00\u001b[A\u001b[A\u001b[A\u001b[A\n",
      "\n",
      "\n",
      "\n",
      "Upload file dqn-CartPole-v1/policy.optimizer.pth: 100%|█| 533k/533k [00:04<00:00\u001b[A\u001b[A\u001b[A\u001b[A\n",
      "\u001b[38;5;4mℹ Your model is pushed to the hub. You can view your model here:\n",
      "https://huggingface.co/nsanghi/dqn-cart-pole-rlzoo\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "!python -m rl_zoo3.push_to_hub --algo dqn --env CartPole-v1 --exp-id 0 \\\n",
    "--folder logs/6_a/rlzoo3 --n-timesteps 1000 --verbose 1 --load-best  \\\n",
    "--organization nsanghi --repo-name dqn-cart-pole-rlzoo -m \"Push to Hub\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0FrLtZk6lNva"
   },
   "source": [
    "#### HyperParameter Optimization\n",
    "In case you want to further optimize the hyperparameters of the model, you can run something like this. It uses the values as defined in [`hyperparams_opt.py`](https://github.com/DLR-RM/rl-baselines3-zoo/blob/master/rl_zoo3/hyperparams_opt.py#L386) to carry out search over a wide range of hyperparameters using [Optuna](https://optuna.org/). You can follow these links and rl_zoo3 documentation for more details.\n",
    "\n",
    "Do not run the below cell unless you have a GPU and even then it will take substantial time. with `max-totl-trials=25` it takes about an hour on a cpu. This number needs to be increased to 100-300 for a decent search of the parameter space."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "kznh6TsOlNva"
   },
   "outputs": [],
   "source": [
    "# !python -m rl_zoo3.train --algo dqn --env CartPole-v1 --save-freq 10000 \\\n",
    "# --eval-episodes 10 --log-interval 100 --progress --track \\\n",
    "# --wandb-project-name dqn-cartpole \\\n",
    "# --optimization-log-path logs/optimization/ --log-folder logs --optimize-hyperparameters --n-jobs 2 \\\n",
    "# --study-name dqn-test --max-total-trials 25"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8xRqkMgKlNva"
   },
   "source": [
    "**For doing a parsing of optimization study**\n",
    "\n",
    "Please refer to RL Zoo3 documentation for further details."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "0KlstELGlNva"
   },
   "outputs": [],
   "source": [
    "# !python -m rl_z003.scripts.parse_study -i ./logs/dqn/report_CartPole-v1_500-trials-50000-tpe-median_1698290229.pkl --print-n-best-trials 10 \\\n",
    "# --save-n-best-hyperparameters 10 --folder ./logs/dqn/6.a/best-params/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Z2iSAfUVlNvb"
   },
   "source": [
    "#### Plotting the charts\n",
    "We need to have multiple training run outputs. So we run it once more"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "igPaD85QlNvb",
    "outputId": "17678bfd-f023-4c31-ab81-c22c6b270958"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2023-11-05 07:33:37.740322: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
      "2023-11-05 07:33:37.783308: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
      "2023-11-05 07:33:37.783402: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
      "2023-11-05 07:33:37.783432: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
      "2023-11-05 07:33:37.790973: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 AVX_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2023-11-05 07:33:38.798167: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n",
      "========== CartPole-v1 ==========\n",
      "Seed: 2982996057\n",
      "\u001b[34m\u001b[1mwandb\u001b[0m: Currently logged in as: \u001b[33mnsanghi\u001b[0m. Use \u001b[1m`wandb login --relogin`\u001b[0m to force relogin\n",
      "\u001b[34m\u001b[1mwandb\u001b[0m: Tracking run with wandb version 0.15.12\n",
      "\u001b[34m\u001b[1mwandb\u001b[0m: Run data is saved locally in \u001b[35m\u001b[1m/home/nsanghi/sandbox/apress/drl-2ed/chapter6/wandb/run-20231105_073342-42hkvdlu\u001b[0m\n",
      "\u001b[34m\u001b[1mwandb\u001b[0m: Run \u001b[1m`wandb offline`\u001b[0m to turn off syncing.\n",
      "\u001b[34m\u001b[1mwandb\u001b[0m: Syncing run \u001b[33mCartPole-v1__dqn__2982996057__1699149821\u001b[0m\n",
      "\u001b[34m\u001b[1mwandb\u001b[0m: ⭐️ View project at \u001b[34m\u001b[4mhttps://wandb.ai/nsanghi/dqn-cartpole\u001b[0m\n",
      "\u001b[34m\u001b[1mwandb\u001b[0m: 🚀 View run at \u001b[34m\u001b[4mhttps://wandb.ai/nsanghi/dqn-cartpole/runs/42hkvdlu\u001b[0m\n",
      "Loading hyperparameters from: /home/nsanghi/sandbox/apress/drl-2ed/venv/lib/python3.10/site-packages/rl_zoo3/hyperparams/dqn.yml\n",
      "Default hyperparameters for environment (ones being tuned will be overridden):\n",
      "OrderedDict([('batch_size', 64),\n",
      "             ('buffer_size', 100000),\n",
      "             ('exploration_final_eps', 0.04),\n",
      "             ('exploration_fraction', 0.16),\n",
      "             ('gamma', 0.99),\n",
      "             ('gradient_steps', 128),\n",
      "             ('learning_rate', 0.0023),\n",
      "             ('learning_starts', 1000),\n",
      "             ('n_timesteps', 50000.0),\n",
      "             ('policy', 'MlpPolicy'),\n",
      "             ('policy_kwargs', 'dict(net_arch=[256, 256])'),\n",
      "             ('target_update_interval', 10),\n",
      "             ('train_freq', 256)])\n",
      "Using 1 environments\n",
      "Creating test environment\n",
      "Using cpu device\n",
      "Log path: logs/6_a/rlzoo3//dqn/CartPole-v1_4\n",
      "Logging to runs/CartPole-v1__dqn__2982996057__1699149821/CartPole-v1/DQN_1\n",
      "\u001b[2KEval num_timesteps=10000, episode_reward=92.40 +/- 2.69━━━━━━━━━━\u001b[0m \u001b[32m9,976/50,000 \u001b[0m [ \u001b[33m0:00:45\u001b[0m < \u001b[36m0:03:36\u001b[0m , \u001b[31m186 it/s\u001b[0m ]\n",
      "\u001b[2KEpisode length: 92.40 +/- 2.69╺\u001b[0m\u001b[90m━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m9,976/50,000 \u001b[0m [ \u001b[33m0:00:45\u001b[0m < \u001b[36m0:03:36\u001b[0m , \u001b[31m186 it/s\u001b[0m ]\n",
      "\u001b[2K----------------------------------m\u001b[90m━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m9,976/50,000 \u001b[0m [ \u001b[33m0:00:45\u001b[0m < \u001b[36m0:03:36\u001b[0m , \u001b[31m186 it/s\u001b[0m ]\n",
      "| eval/               |          |\n",
      "|    mean_ep_length   | 92.4     |\n",
      "|    mean_reward      | 92.4     |\n",
      "| rollout/            |          |\n",
      "|    exploration_rate | 0.04     |\n",
      "| time/               |          |\n",
      "|    total_timesteps  | 10000    |\n",
      "| train/              |          |\n",
      "|    learning_rate    | 0.0023   |\n",
      "|    loss             | 0.276    |\n",
      "|    n_updates        | 4608     |\n",
      "----------------------------------\n",
      "\u001b[2KNew best mean reward!\u001b[0m\u001b[90m╺\u001b[0m\u001b[90m━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m9,976/50,000 \u001b[0m [ \u001b[33m0:00:45\u001b[0m < \u001b[36m0:03:36\u001b[0m , \u001b[31m186 it/s\u001b[0m ]\n",
      "\u001b[2KEval num_timesteps=20000, episode_reward=30.40 +/- 20.38━━━━━━━━\u001b[0m \u001b[32m19,919/50,000 \u001b[0m [ \u001b[33m0:01:34\u001b[0m < \u001b[36m0:02:17\u001b[0m , \u001b[31m221 it/s\u001b[0m ]\n",
      "\u001b[2KEpisode length: 30.40 +/- 20.38[90m╺\u001b[0m\u001b[90m━━━━━━━━━━━━━━━\u001b[0m \u001b[32m19,919/50,000 \u001b[0m [ \u001b[33m0:01:34\u001b[0m < \u001b[36m0:02:17\u001b[0m , \u001b[31m221 it/s\u001b[0m ]\n",
      "\u001b[2K----------------------------------m╺\u001b[0m\u001b[90m━━━━━━━━━━━━━━━\u001b[0m \u001b[32m19,919/50,000 \u001b[0m [ \u001b[33m0:01:34\u001b[0m < \u001b[36m0:02:17\u001b[0m , \u001b[31m221 it/s\u001b[0m ]\n",
      "| eval/               |          |\n",
      "|    mean_ep_length   | 30.4     |\n",
      "|    mean_reward      | 30.4     |\n",
      "| rollout/            |          |\n",
      "|    exploration_rate | 0.04     |\n",
      "| time/               |          |\n",
      "|    total_timesteps  | 20000    |\n",
      "| train/              |          |\n",
      "|    learning_rate    | 0.0023   |\n",
      "|    loss             | 0.495    |\n",
      "|    n_updates        | 9600     |\n",
      "----------------------------------\n",
      "\u001b[2K----------------------------------m\u001b[91m╸\u001b[0m\u001b[90m━━━━━━━━━━━━━━\u001b[0m \u001b[32m22,325/50,000 \u001b[0m [ \u001b[33m0:01:45\u001b[0m < \u001b[36m0:02:13\u001b[0m , \u001b[31m209 it/s\u001b[0m ]\n",
      "| rollout/            |          |\n",
      "|    ep_len_mean      | 64.1     |\n",
      "|    ep_rew_mean      | 64.1     |\n",
      "|    exploration_rate | 0.04     |\n",
      "| time/               |          |\n",
      "|    episodes         | 400      |\n",
      "|    fps              | 212      |\n",
      "|    time_elapsed     | 105      |\n",
      "|    total_timesteps  | 22468    |\n",
      "| train/              |          |\n",
      "|    learning_rate    | 0.0023   |\n",
      "|    loss             | 0.695    |\n",
      "|    n_updates        | 10752    |\n",
      "----------------------------------\n",
      "\u001b[2KEval num_timesteps=30000, episode_reward=145.80 +/- 3.22━━━━━━━━\u001b[0m \u001b[32m29,948/50,000 \u001b[0m [ \u001b[33m0:02:31\u001b[0m < \u001b[36m0:01:59\u001b[0m , \u001b[31m170 it/s\u001b[0m ]\n",
      "\u001b[2KEpisode length: 145.80 +/- 3.22\u001b[0m\u001b[91m╸\u001b[0m\u001b[90m━━━━━━━━━━\u001b[0m \u001b[32m29,948/50,000 \u001b[0m [ \u001b[33m0:02:31\u001b[0m < \u001b[36m0:01:59\u001b[0m , \u001b[31m170 it/s\u001b[0m ]\n",
      "\u001b[2K----------------------------------m\u001b[91m╸\u001b[0m\u001b[90m━━━━━━━━━━\u001b[0m \u001b[32m29,948/50,000 \u001b[0m [ \u001b[33m0:02:31\u001b[0m < \u001b[36m0:01:59\u001b[0m , \u001b[31m170 it/s\u001b[0m ]\n",
      "| eval/               |          |\n",
      "|    mean_ep_length   | 146      |\n",
      "|    mean_reward      | 146      |\n",
      "| rollout/            |          |\n",
      "|    exploration_rate | 0.04     |\n",
      "| time/               |          |\n",
      "|    total_timesteps  | 30000    |\n",
      "| train/              |          |\n",
      "|    learning_rate    | 0.0023   |\n",
      "|    loss             | 0.771    |\n",
      "|    n_updates        | 14592    |\n",
      "----------------------------------\n",
      "\u001b[2KNew best mean reward!━━━━━━━━━━\u001b[0m\u001b[91m╸\u001b[0m\u001b[90m━━━━━━━━━━\u001b[0m \u001b[32m29,948/50,000 \u001b[0m [ \u001b[33m0:02:31\u001b[0m < \u001b[36m0:01:59\u001b[0m , \u001b[31m170 it/s\u001b[0m ]\n",
      "\u001b[2KEval num_timesteps=40000, episode_reward=500.00 +/- 0.0090m━━━━━\u001b[0m \u001b[32m39,985/50,000 \u001b[0m [ \u001b[33m0:03:23\u001b[0m < \u001b[36m0:00:49\u001b[0m , \u001b[31m206 it/s\u001b[0m ]\n",
      "\u001b[2KEpisode length: 500.00 +/- 0.00━━━━━\u001b[0m\u001b[91m╸\u001b[0m\u001b[90m━━━━━\u001b[0m \u001b[32m39,985/50,000 \u001b[0m [ \u001b[33m0:03:23\u001b[0m < \u001b[36m0:00:49\u001b[0m , \u001b[31m206 it/s\u001b[0m ]\n",
      "\u001b[2K----------------------------------━━\u001b[0m\u001b[91m╸\u001b[0m\u001b[90m━━━━━\u001b[0m \u001b[32m39,985/50,000 \u001b[0m [ \u001b[33m0:03:23\u001b[0m < \u001b[36m0:00:49\u001b[0m , \u001b[31m206 it/s\u001b[0m ]\n",
      "| eval/               |          |\n",
      "|    mean_ep_length   | 500      |\n",
      "|    mean_reward      | 500      |\n",
      "| rollout/            |          |\n",
      "|    exploration_rate | 0.04     |\n",
      "| time/               |          |\n",
      "|    total_timesteps  | 40000    |\n",
      "| train/              |          |\n",
      "|    learning_rate    | 0.0023   |\n",
      "|    loss             | 0.541    |\n",
      "|    n_updates        | 19584    |\n",
      "----------------------------------\n",
      "\u001b[2KNew best mean reward!━━━━━━━━━━━━━━━\u001b[0m\u001b[91m╸\u001b[0m\u001b[90m━━━━━\u001b[0m \u001b[32m39,985/50,000 \u001b[0m [ \u001b[33m0:03:23\u001b[0m < \u001b[36m0:00:49\u001b[0m , \u001b[31m206 it/s\u001b[0m ]\n",
      "\u001b[2KEval num_timesteps=50000, episode_reward=37.70 +/- 42.46[0m \u001b[32m49,921/50,000 \u001b[0m [ \u001b[33m0:04:11\u001b[0m < \u001b[36m0:00:01\u001b[0m , \u001b[31m211 it/s\u001b[0m ]t/s\u001b[0m ]\n",
      "\u001b[2KEpisode length: 37.70 +/- 42.46━━━━━━━━━━\u001b[0m\u001b[91m╸\u001b[0m \u001b[32m49,921/50,000 \u001b[0m [ \u001b[33m0:04:11\u001b[0m < \u001b[36m0:00:01\u001b[0m , \u001b[31m211 it/s\u001b[0m ]\n",
      "\u001b[2K----------------------------------━━━━━━━\u001b[0m\u001b[91m╸\u001b[0m \u001b[32m49,921/50,000 \u001b[0m [ \u001b[33m0:04:11\u001b[0m < \u001b[36m0:00:01\u001b[0m , \u001b[31m211 it/s\u001b[0m ]\n",
      "| eval/               |          |\n",
      "|    mean_ep_length   | 37.7     |\n",
      "|    mean_reward      | 37.7     |\n",
      "| rollout/            |          |\n",
      "|    exploration_rate | 0.04     |\n",
      "| time/               |          |\n",
      "|    total_timesteps  | 50000    |\n",
      "| train/              |          |\n",
      "|    learning_rate    | 0.0023   |\n",
      "|    loss             | 0.826    |\n",
      "|    n_updates        | 24576    |\n",
      "----------------------------------\n",
      "\u001b[2K\u001b[35m 100%\u001b[0m \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m50,176/50,000 \u001b[0m [ \u001b[33m0:04:11\u001b[0m < \u001b[36m0:00:00\u001b[0m , \u001b[31m213 it/s\u001b[0m ][0m ]\n",
      "\u001b[?25hSaving to logs/6_a/rlzoo3//dqn/CartPole-v1_4\n"
     ]
    }
   ],
   "source": [
    "!python -m rl_zoo3.train --algo dqn --env CartPole-v1 --save-freq 10000 \\\n",
    "--eval-freq 10000 --eval-episodes 10 --log-interval 400 --progress \\\n",
    "--track --wandb-project-name dqn-cartpole -f logs/6_a/rlzoo3/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Wjuinsm-lNvb"
   },
   "source": [
    "#### Prepare the results File\n",
    "Here we have done only two runs and therefore the results will not be anything great. In a real use case you will have multiple runs ans then you will plot the performance charts. You can refer to the code file and documentation for more details"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "AA5zj7YJlNvc",
    "outputId": "73e02cb6-fe17-4efe-99ba-b6c69a64ae2b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2023-11-05 07:38:09.673882: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
      "2023-11-05 07:38:09.762558: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
      "2023-11-05 07:38:09.762658: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
      "2023-11-05 07:38:09.762691: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
      "2023-11-05 07:38:09.777402: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 AVX_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2023-11-05 07:38:10.576045: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n",
      "/usr/lib/python3.10/runpy.py:126: RuntimeWarning: 'rl_zoo3.plots.all_plots' found in sys.modules after import of package 'rl_zoo3.plots', but prior to execution of 'rl_zoo3.plots.all_plots'; this may result in unpredictable behaviour\n",
      "  warn(RuntimeWarning(msg))\n",
      "# results_table\n",
      "|Environments|      DQN       |\n",
      "|------------|----------------|\n",
      "|            |logs/6_a/rlzoo3/|\n",
      "|CartPole-v1 |374 +/- 97      |\n",
      "Saving to logs/6_a/rlzoo3/dqn_results.pkl\n",
      "Figure(640x480)\n"
     ]
    }
   ],
   "source": [
    "!python -m rl_zoo3.plots.all_plots --algo dqn --env CartPole-v1 \\\n",
    "-f logs/6_a/rlzoo3/ -o logs/6_a/rlzoo3/dqn_results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xRl06W__lNvc"
   },
   "source": [
    "#### Plot the results in a svg file\n",
    "Open the svg file after you run the command below. Path of the svg file is given in the command"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "7TMlt-pMlNvc",
    "outputId": "b6806c25-76ae-403f-fa4b-651ca93e95a1"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2023-11-05 07:38:30.331280: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
      "2023-11-05 07:38:30.369413: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
      "2023-11-05 07:38:30.369494: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
      "2023-11-05 07:38:30.369526: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
      "2023-11-05 07:38:30.376612: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 AVX_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2023-11-05 07:38:31.116152: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n",
      "/usr/lib/python3.10/runpy.py:126: RuntimeWarning: 'rl_zoo3.plots.plot_from_file' found in sys.modules after import of package 'rl_zoo3.plots', but prior to execution of 'rl_zoo3.plots.plot_from_file'; this may result in unpredictable behaviour\n",
      "  warn(RuntimeWarning(msg))\n",
      "# results_table\n",
      "|Environments|      DQN       |\n",
      "|------------|----------------|\n",
      "|            |logs/6_a/rlzoo3/|\n",
      "|CartPole-v1 |374 +/- 97      |\n",
      "keys: ['DQN-logs/6_a/rlzoo3/']\n",
      "Figure(640x480)\n",
      "Figure(640x480)\n"
     ]
    }
   ],
   "source": [
    "!python -m rl_zoo3.plots.plot_from_file -i logs/6_a/rlzoo3/dqn_results.pkl \\\n",
    "-latex -l DQN --output logs/6_a/rlzoo3/dqn_test_plot.svg"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dSmd6xZglNvd"
   },
   "source": [
    "#### Rliable plot\n",
    "When you run this you will see error like:\n",
    "```\n",
    "CartPole-v1 not found for normalizing scores, you should update `env_key_to_env_id`\n",
    "  warnings.warn(f\"{env} not found for normalizing scores, you should update `env_key_to_env_id`\")\n",
    "```\n",
    "To fix this you can refer to the instructions towards the end of the page at [this link](https://rl-baselines3-zoo.readthedocs.io/en/master/guide/plot.html)\n",
    "\n",
    "The provided code in its current form is meant for a few PyBullet environments and does not do normalization for other environments. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "id": "wdvwjsmFlNvd",
    "outputId": "47a960db-4ace-4573-c428-abf0772a21e5"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2023-11-05 07:39:24.856501: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
      "2023-11-05 07:39:24.910207: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
      "2023-11-05 07:39:24.910298: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
      "2023-11-05 07:39:24.910325: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
      "2023-11-05 07:39:24.917149: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 AVX_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2023-11-05 07:39:25.650596: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n",
      "/usr/lib/python3.10/runpy.py:126: RuntimeWarning: 'rl_zoo3.plots.plot_from_file' found in sys.modules after import of package 'rl_zoo3.plots', but prior to execution of 'rl_zoo3.plots.plot_from_file'; this may result in unpredictable behaviour\n",
      "  warn(RuntimeWarning(msg))\n",
      "# results_table\n",
      "|Environments|      DQN       |\n",
      "|------------|----------------|\n",
      "|            |logs/6_a/rlzoo3/|\n",
      "|CartPole-v1 |374 +/- 97      |\n",
      "keys: ['DQN-logs/6_a/rlzoo3/']\n",
      "/home/nsanghi/sandbox/apress/drl-2ed/venv/lib/python3.10/site-packages/rl_zoo3/plots/plot_from_file.py:192: UserWarning: CartPole-v1 not found for normalizing scores, you should update `env_key_to_env_id`\n",
      "  warnings.warn(f\"{env} not found for normalizing scores, you should update `env_key_to_env_id`\")\n",
      "Computing bootstrap CI ...\n",
      "/home/nsanghi/sandbox/apress/drl-2ed/venv/lib/python3.10/site-packages/rl_zoo3/plots/plot_from_file.py:249: UserWarning: Tight layout not applied. The bottom and top margins cannot be made large enough to accommodate all axes decorations.\n",
      "  plt.tight_layout()\n",
      "Figure(640x480)\n",
      "Figure(2000x100)\n",
      "Figure(700x500)\n",
      "Figure(1000x800)\n",
      "Figure(700x500)\n",
      "Figure(640x480)\n",
      "Figure(640x480)\n"
     ]
    }
   ],
   "source": [
    "!python -m rl_zoo3.plots.plot_from_file -i logs/6_a/rlzoo3/dqn_results.pkl \\\n",
    "--rliable --versus --iqm --boxplot \\\n",
    "-latex -l DQN --output logs/6_a/rlzoo3/dqn_test1_plot.svg"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YM8yEul4lNvd"
   },
   "source": [
    "### Summary\n",
    "\n",
    "In this notebook we saw how to train a DQN agent with experience replay and target networks. We can improve this agent with many tricks. As we go along, we will be implementing many of these variants."
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "gpuType": "T4",
   "include_colab_link": true,
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.18"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "00a35b9fb31b44e888d17102ef7dc281": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "0189405cd3f94bf7bd35913a0a890c13": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "0cfbdbacc76a4b0199006b521e3a8650": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "0d85825c1689408685a26cb2db3126f4": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "success",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_b9101353863f465d88d9c21e4ca92f07",
      "max": 546080,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_a0e86af7f02f4e968857f6283d2c5fdd",
      "value": 546080
     }
    },
    "0e9e596b2fa546f8a35e32fe31db028a": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "11a42b7711f2472db6c9f05b697390cd": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "VBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "VBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "VBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_bf51823cc5f84ed1a34dc3779ac7b173",
       "IPY_MODEL_2f19a722ab4041dab88d362f16dbb200",
       "IPY_MODEL_bed2844d22664a00811964c91a03cdd6",
       "IPY_MODEL_9ef1ccf4e0e14f8f806962d72c7574e5"
      ],
      "layout": "IPY_MODEL_ede351d45bac43db8fc76a894fcfacf0"
     }
    },
    "13bfe3534cd44a5285e8468047b5f693": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "18b5099ea6754704a7413d850478ed9e": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_13bfe3534cd44a5285e8468047b5f693",
      "placeholder": "​",
      "style": "IPY_MODEL_cc3569e5d5044030b73a8bbb32c961e3",
      "value": "\n<b>Pro Tip:</b> If you don't already have one, you can create a dedicated\n'notebooks' token with 'write' access, that you can then easily reuse for all\nnotebooks. </center>"
     }
    },
    "1ae68f5b0bcd470bb087ba94367113f6": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "1cbc7e0ebc5047f5a61a80b519ebce41": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_de4841ea039b4117a03fb05ac455194f",
      "placeholder": "​",
      "style": "IPY_MODEL_914ffdd6feb14f4a9f61f4de076c77f9",
      "value": "policy.pth: 100%"
     }
    },
    "1f2869485d6e4cc0afc1cf1f39500eb3": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "21145d76a7e24644acbc55d87c935d24": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ButtonModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ButtonModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ButtonView",
      "button_style": "",
      "description": "Login",
      "disabled": false,
      "icon": "",
      "layout": "IPY_MODEL_ab20961674f14a8cba2bfe814e48c25c",
      "style": "IPY_MODEL_834a9d2efe174c7d9ff72d3277919fd2",
      "tooltip": ""
     }
    },
    "2f19a722ab4041dab88d362f16dbb200": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "LabelModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "LabelModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "LabelView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_f8910f13f12f42eb8518f539136fa90c",
      "placeholder": "​",
      "style": "IPY_MODEL_1f2869485d6e4cc0afc1cf1f39500eb3",
      "value": "Your token has been saved in your configured git credential helpers (store)."
     }
    },
    "38a421e00dff415094cfcaf9b42e6c87": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "43c442a374224e27a1a043bcea0a43ee": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "45005e8941d04abb9ced51bbc2d838cb": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "4bc6579073c445e593c74227774f19ee": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "CheckboxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "CheckboxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "CheckboxView",
      "description": "Add token as git credential?",
      "description_tooltip": null,
      "disabled": false,
      "indent": true,
      "layout": "IPY_MODEL_38a421e00dff415094cfcaf9b42e6c87",
      "style": "IPY_MODEL_983c23d230954debb757b9e425d76531",
      "value": true
     }
    },
    "4c1c9a99b72d4914813016cc3c0c0120": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "4e7dd242ae574110a9b2884b30946492": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "5a251c49122d495893ee95026a5f5c58": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "5a5055a2d85f4f03af3fb9782d9e33b2": {
     "model_module": "@jupyter-widgets/output",
     "model_module_version": "1.0.0",
     "model_name": "OutputModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/output",
      "_model_module_version": "1.0.0",
      "_model_name": "OutputModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/output",
      "_view_module_version": "1.0.0",
      "_view_name": "OutputView",
      "layout": "IPY_MODEL_da89e5f6ee4c4030a4b43897d12061f6",
      "msg_id": "",
      "outputs": [
       {
        "data": {
         "text/html": "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #800080; text-decoration-color: #800080\"> 100%</span> <span style=\"color: #f92672; text-decoration-color: #f92672\">━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╸</span> <span style=\"color: #008000; text-decoration-color: #008000\">99,926/100,000 </span> [ <span style=\"color: #808000; text-decoration-color: #808000\">0:01:43</span> &lt; <span style=\"color: #008080; text-decoration-color: #008080\">0:00:01</span> , <span style=\"color: #800000; text-decoration-color: #800000\">538 it/s</span> ]\n</pre>\n",
         "text/plain": "\u001b[35m 100%\u001b[0m \u001b[38;2;249;38;114m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[38;2;249;38;114m╸\u001b[0m \u001b[32m99,926/100,000 \u001b[0m [ \u001b[33m0:01:43\u001b[0m < \u001b[36m0:00:01\u001b[0m , \u001b[31m538 it/s\u001b[0m ]\n"
        },
        "metadata": {},
        "output_type": "display_data"
       }
      ]
     }
    },
    "5a81f7cec2cc47c59e33e9e9c94eb872": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "success",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_4e7dd242ae574110a9b2884b30946492",
      "max": 1108374,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_5c987bce21bc462d97383e2769bc1fa4",
      "value": 1108374
     }
    },
    "5c987bce21bc462d97383e2769bc1fa4": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": ""
     }
    },
    "620cb12fe87543048b142d5c057e0c21": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": ""
     }
    },
    "63bb34cf28dd46609e286dc4d597656c": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "63f2cafdc4a84bd981c66e605dd974cc": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": ""
     }
    },
    "6ba119043fd04129a619b09cf9cf8c0d": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "6e5da7aecf794c0cac1dfd17236a325e": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_bd7e4a6b879341bda592ea3c00ba6b0c",
      "placeholder": "​",
      "style": "IPY_MODEL_0cfbdbacc76a4b0199006b521e3a8650",
      "value": " 3/3 [00:01&lt;00:00,  2.23it/s]"
     }
    },
    "73ec67c0e09d4bb0b7758012408bc99b": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_8c1f86e0b62d44ee96df8420284ee0e9",
      "placeholder": "​",
      "style": "IPY_MODEL_9c6de0d8f8b84a0aa239c1d549b4d999",
      "value": "<center> <img\nsrc=https://huggingface.co/front/assets/huggingface_logo-noborder.svg\nalt='Hugging Face'> <br> Copy a token from <a\nhref=\"https://huggingface.co/settings/tokens\" target=\"_blank\">your Hugging Face\ntokens page</a> and paste it below. <br> Immediately click login after copying\nyour token or it might be stored in plain text in this notebook file. </center>"
     }
    },
    "74769575b5d54624bf2f27b79da53ceb": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_1cbc7e0ebc5047f5a61a80b519ebce41",
       "IPY_MODEL_a55f0be1d4e5423a9b59907bbf39de68",
       "IPY_MODEL_784f54d24898436b99d5ea528084818d"
      ],
      "layout": "IPY_MODEL_b7a8d44c22464af88da030b844ad21b8"
     }
    },
    "784f54d24898436b99d5ea528084818d": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_a17785a5694846b899944437d401d4da",
      "placeholder": "​",
      "style": "IPY_MODEL_ee1d7c957f484533aaf1a034ba3987fa",
      "value": " 545k/545k [00:00&lt;00:00, 39.0kB/s]"
     }
    },
    "7ae36bb772bf4f1ebcc17a502dd3f225": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "834a9d2efe174c7d9ff72d3277919fd2": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ButtonStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ButtonStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "button_color": null,
      "font_weight": ""
     }
    },
    "83a01ff27a5e4a6792bc8de4d590f65a": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "8c1f86e0b62d44ee96df8420284ee0e9": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "8d2715edba2f408d8aca3f1e0ea1f530": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "8f708d5f4041454195bef849e5153324": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "success",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_7ae36bb772bf4f1ebcc17a502dd3f225",
      "max": 3,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_63f2cafdc4a84bd981c66e605dd974cc",
      "value": 3
     }
    },
    "8fac41ff159a47b69e35230f519da9a7": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "8fdb412710684e07a56a7f2ac85bcd54": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_1ae68f5b0bcd470bb087ba94367113f6",
      "placeholder": "​",
      "style": "IPY_MODEL_43c442a374224e27a1a043bcea0a43ee",
      "value": " 1.11M/1.11M [00:00&lt;00:00, 40.1kB/s]"
     }
    },
    "914ffdd6feb14f4a9f61f4de076c77f9": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "96647e54ce954f63b43b8177dd28d704": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_a46148600bed4f61a43fb844cd156665",
      "placeholder": "​",
      "style": "IPY_MODEL_a067e9850d1c43b188b0a1e9a2303a72",
      "value": "DQN-CartPole-v1.zip: 100%"
     }
    },
    "983c23d230954debb757b9e425d76531": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "9c6de0d8f8b84a0aa239c1d549b4d999": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "9ef1ccf4e0e14f8f806962d72c7574e5": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "LabelModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "LabelModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "LabelView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_e2157c13296a43afa159d6996c5a8753",
      "placeholder": "​",
      "style": "IPY_MODEL_00a35b9fb31b44e888d17102ef7dc281",
      "value": "Login successful"
     }
    },
    "9fdc8261f8e64d4ea995e783dba61cbd": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "LabelModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "LabelModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "LabelView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_b48b14bdbf574dcebc6930558a5ad035",
      "placeholder": "​",
      "style": "IPY_MODEL_f086412ef371478f87d981796e0a51f6",
      "value": "Connecting..."
     }
    },
    "a067e9850d1c43b188b0a1e9a2303a72": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "a0e86af7f02f4e968857f6283d2c5fdd": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": ""
     }
    },
    "a17785a5694846b899944437d401d4da": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "a46148600bed4f61a43fb844cd156665": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "a55f0be1d4e5423a9b59907bbf39de68": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "success",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_63bb34cf28dd46609e286dc4d597656c",
      "max": 545202,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_620cb12fe87543048b142d5c057e0c21",
      "value": 545202
     }
    },
    "a79a2fb3f81e4214bd69d563ccbb91c6": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_83a01ff27a5e4a6792bc8de4d590f65a",
      "placeholder": "​",
      "style": "IPY_MODEL_4c1c9a99b72d4914813016cc3c0c0120",
      "value": " 546k/546k [00:00&lt;00:00, 39.4kB/s]"
     }
    },
    "a964a4d69eb74a6aae5750c577915ca0": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "a96c4337763e48c88591f6a183770c4a": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "ab20961674f14a8cba2bfe814e48c25c": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "b25455a01a364331a71f427e45b8d566": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "b293121597f8442b951f260db5fa77d4": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "PasswordModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "PasswordModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "PasswordView",
      "continuous_update": true,
      "description": "Token:",
      "description_tooltip": null,
      "disabled": false,
      "layout": "IPY_MODEL_5a251c49122d495893ee95026a5f5c58",
      "placeholder": "​",
      "style": "IPY_MODEL_a964a4d69eb74a6aae5750c577915ca0",
      "value": ""
     }
    },
    "b48b14bdbf574dcebc6930558a5ad035": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "b7a8d44c22464af88da030b844ad21b8": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "b9101353863f465d88d9c21e4ca92f07": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "b9c91a633fa6434c864411a79f5edfbf": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_e380bd88e6524613bf782090d8372e0c",
       "IPY_MODEL_8f708d5f4041454195bef849e5153324",
       "IPY_MODEL_6e5da7aecf794c0cac1dfd17236a325e"
      ],
      "layout": "IPY_MODEL_c803d98649064086916e72d630f55ef3"
     }
    },
    "bc315f24524848c4a9bc940bfb00a959": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "bd7e4a6b879341bda592ea3c00ba6b0c": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "bed2844d22664a00811964c91a03cdd6": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "LabelModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "LabelModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "LabelView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_a96c4337763e48c88591f6a183770c4a",
      "placeholder": "​",
      "style": "IPY_MODEL_0e9e596b2fa546f8a35e32fe31db028a",
      "value": "Your token has been saved to /root/.cache/huggingface/token"
     }
    },
    "bf51823cc5f84ed1a34dc3779ac7b173": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "LabelModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "LabelModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "LabelView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_6ba119043fd04129a619b09cf9cf8c0d",
      "placeholder": "​",
      "style": "IPY_MODEL_0189405cd3f94bf7bd35913a0a890c13",
      "value": "Token is valid (permission: write)."
     }
    },
    "c5b76670d2554feeb632a3013aca2962": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_d77d049d43b34989a7b150446b2a87e2",
       "IPY_MODEL_0d85825c1689408685a26cb2db3126f4",
       "IPY_MODEL_a79a2fb3f81e4214bd69d563ccbb91c6"
      ],
      "layout": "IPY_MODEL_bc315f24524848c4a9bc940bfb00a959"
     }
    },
    "c803d98649064086916e72d630f55ef3": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "cc3569e5d5044030b73a8bbb32c961e3": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "d6a18ae8bfc44987a1298820cf0caab2": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_96647e54ce954f63b43b8177dd28d704",
       "IPY_MODEL_5a81f7cec2cc47c59e33e9e9c94eb872",
       "IPY_MODEL_8fdb412710684e07a56a7f2ac85bcd54"
      ],
      "layout": "IPY_MODEL_8d2715edba2f408d8aca3f1e0ea1f530"
     }
    },
    "d77d049d43b34989a7b150446b2a87e2": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_8fac41ff159a47b69e35230f519da9a7",
      "placeholder": "​",
      "style": "IPY_MODEL_b25455a01a364331a71f427e45b8d566",
      "value": "policy.optimizer.pth: 100%"
     }
    },
    "da89e5f6ee4c4030a4b43897d12061f6": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "de4841ea039b4117a03fb05ac455194f": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "e1117f6bdaec48b2a24c103daf4181b4": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "e2157c13296a43afa159d6996c5a8753": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "e380bd88e6524613bf782090d8372e0c": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_45005e8941d04abb9ced51bbc2d838cb",
      "placeholder": "​",
      "style": "IPY_MODEL_e1117f6bdaec48b2a24c103daf4181b4",
      "value": "Upload 3 LFS files: 100%"
     }
    },
    "ede351d45bac43db8fc76a894fcfacf0": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": "center",
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": "flex",
      "flex": null,
      "flex_flow": "column",
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": "50%"
     }
    },
    "ee1d7c957f484533aaf1a034ba3987fa": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "f086412ef371478f87d981796e0a51f6": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "f8910f13f12f42eb8518f539136fa90c": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    }
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
